@Override
  public Iterator<Resource> iterateResources(String startPath, boolean recursive) {

    // Collect paths for substituted packages
    List<String> importedPaths = new ArrayList<String>();
    BundleWiring wiring = hostRev.getBundle().adapt(BundleWiring.class);
    List<BundleRequirement> preqs =
        wiring != null ? wiring.getRequirements(PackageNamespace.PACKAGE_NAMESPACE) : null;
    if (preqs != null) {
      for (BundleRequirement req : preqs) {
        XPackageRequirement preq = (XPackageRequirement) req;
        String packageName = preq.getPackageName();
        importedPaths.add(packageName.replace('.', '/'));
      }
    }
    Iterator<Resource> itres = delegate.iterateResources(startPath, recursive);
    if (importedPaths.isEmpty()) {
      return itres;
    }

    // Filter substituted packages
    List<Resource> filteredResources = new ArrayList<Resource>();
    while (itres.hasNext()) {
      Resource res = itres.next();
      String pathname = res.getName();
      int lastIndex = pathname.lastIndexOf('/');
      String respath = lastIndex > 0 ? pathname.substring(0, lastIndex) : pathname;
      if (!importedPaths.contains(respath)) {
        filteredResources.add(res);
      }
    }

    return filteredResources.iterator();
  }
Пример #2
0
  private Manifest getManifest() throws IOException {
    if (manifest != null) return manifest;

    final Resource manifestResource = getResource("META-INF/MANIFEST.MF");
    if (manifestResource == null) return null;
    final InputStream manifestStream = manifestResource.openStream();
    try {
      manifest = new Manifest(manifestStream);
    } finally {
      if (manifestStream != null) manifestStream.close();
    }
    return manifest;
  }
Пример #3
0
    @Override
    public Iterable<JavaFileObject> list(
        Location location, String packageName, Set<Kind> kinds, boolean recurse)
        throws IOException {
      if (location == StandardLocation.PLATFORM_CLASS_PATH) {
        return standardJavaFileManager.list(location, packageName, kinds, recurse);
      }
      List<JavaFileObject> ret = new ArrayList<>();
      if (kinds.contains(Kind.CLASS) && location.equals(StandardLocation.CLASS_PATH)) {
        if (classLoader instanceof ModuleClassLoader) {
          ModuleClassLoader mcl = (ModuleClassLoader) classLoader;
          final String packageWithSlashes = packageName.replace(".", "/");
          try {
            Iterator<Resource> resources =
                mcl.getModule()
                    .iterateResources(
                        new PathFilter() {
                          @Override
                          public boolean accept(String path) {
                            if (recurse) {
                              return path.startsWith(packageWithSlashes);
                            } else {
                              return path.equals(packageWithSlashes);
                            }
                          }
                        });
            while (resources.hasNext()) {
              Resource res = resources.next();
              if (!res.getName().endsWith(".class")) {
                continue;
              }
              String binaryName =
                  res.getName().replace("/", ".").substring(0, res.getName().length() - 6);
              try {
                ret.add(
                    new ZipJavaFileObject(
                        org.fakereplace.util.FileReader.readFileBytes(res.openStream()),
                        binaryName,
                        res.getURL().toURI()));
              } catch (URISyntaxException e) {
                e.printStackTrace();
              }
            }
          } catch (ModuleLoadException e) {
            e.printStackTrace();
          }
        } else {
          URL res = classLoader.getResource(packageName.replace(".", "/"));
          if (res != null) {
            if (res.getProtocol().equals("file")) {
              Path dirPath = Paths.get(res.getFile());
              listDir(packageName, dirPath, recurse, ret);
            } else if (res.getProtocol().equals("jar")) {
              JarURLConnection connection = (JarURLConnection) res.openConnection();
              Enumeration<JarEntry> entryEnum = connection.getJarFile().entries();
              while (entryEnum.hasMoreElements()) {
                JarEntry entry = entryEnum.nextElement();
                String name = entry.getName();
                if (name.endsWith(".class") && !entry.isDirectory()) {
                  if (name.startsWith(packageName.replace(".", "/"))) {
                    String rem = name.substring(packageName.length());
                    if (rem.startsWith("/")) {
                      rem = rem.substring(1);
                    }
                    if (!recurse) {
                      if (rem.contains("/")) {
                        continue;
                      }
                    }
                    String binaryName =
                        entry
                            .getName()
                            .replace("/", ".")
                            .substring(0, entry.getName().length() - 6);
                    try {
                      URI uri = new URI(res.toExternalForm() + "/" + rem);
                      ret.add(
                          new ZipJavaFileObject(
                              org.fakereplace.util.FileReader.readFileBytes(
                                  uri.toURL().openStream()),
                              binaryName,
                              uri));
                    } catch (Exception e) {
                      e.printStackTrace();
                    }
                  }
                }
              }
            } else {
              System.err.println(
                  "Could not find package "
                      + packageName
                      + " in "
                      + classLoader
                      + " unknown protocol "
                      + res.getProtocol());
            }
          } else {
            return standardJavaFileManager.list(location, packageName, kinds, recurse);
          }
        }
      } else {
        return standardJavaFileManager.list(location, packageName, kinds, recurse);
      }

      return ret;
    }