Java 类java.nio.file.DirectoryIteratorException 实例源码

/**
 * Recurse down a directory tree, checking all child directories.
 * @param dir
 * @throws DiskErrorException
 */
public static void checkDirs(File dir) throws DiskErrorException {
  checkDir(dir);
  IOException ex = null;
  try (DirectoryStream<java.nio.file.Path> stream =
      Files.newDirectoryStream(dir.toPath())) {
    for (java.nio.file.Path entry: stream) {
      File child = entry.toFile();
      if (child.isDirectory()) {
        checkDirs(child);
      }
    }
  } catch (DirectoryIteratorException de) {
    ex = de.getCause();
  } catch (IOException ie) {
    ex = ie;
  }
  if (ex != null) {
    throw new DiskErrorException("I/O error when open a directory: "
        + dir.toString(), ex);
  }
}

/**
 * Return the complete list of files in a directory as strings.<p/>
 *
 * This is better than File#listDir because it does not ignore IOExceptions.
 *
 * @param dir              The directory to list.
 * @param filter           If non-null, the filter to use when listing
 *                         this directory.
 * @return                 The list of files in the directory.
 *
 * @throws IOException     On I/O error
 */
public static List<String> listDirectory(File dir, FilenameFilter filter)
    throws IOException {
  ArrayList<String> list = new ArrayList<String> ();
  try (DirectoryStream<Path> stream =
           Files.newDirectoryStream(dir.toPath())) {
    for (Path entry: stream) {
      String fileName = entry.getFileName().toString();
      if ((filter == null) || filter.accept(dir, fileName)) {
        list.add(fileName);
      }
    }
  } catch (DirectoryIteratorException e) {
    throw e.getCause();
  }
  return list;
}

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed
    // TODO add your handling code here:
          Path dir = Paths.get(txt_path.getText());
    if (dir.getParent()==null) {
        return;
    }
    dtm.setRowCount(0);

    try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir.getParent())) {
        for (Path file : stream) {

            dtm.addRow(new Object[]{file.getFileName()});
        }
    } catch (IOException | DirectoryIteratorException x) {

    }
    txt_path.setText(dir.getParent().toString());

}

/**
 * Return the complete list of files in a directory as strings.<p/>
 *
 * This is better than File#listDir because it does not ignore IOExceptions.
 *
 * @param dir              The directory to list.
 * @param filter           If non-null, the filter to use when listing
 *                         this directory.
 * @return                 The list of files in the directory.
 *
 * @throws IOException     On I/O error
 */
public static List<String> listDirectory(File dir, FilenameFilter filter)
    throws IOException {
  ArrayList<String> list = new ArrayList<String> ();
  try (DirectoryStream<Path> stream =
           Files.newDirectoryStream(dir.toPath())) {
    for (Path entry: stream) {
      String fileName = entry.getFileName().toString();
      if ((filter == null) || filter.accept(dir, fileName)) {
        list.add(fileName);
      }
    }
  } catch (DirectoryIteratorException e) {
    throw e.getCause();
  }
  return list;
}

@Test
public void testEmptyPackageDirectory(Path base) throws Exception {
    Path src = base.resolve("src");
    createSources(src);

    // need an empty package directory, to check whether
    // the behavior of subpackage and package
    Path pkgdir = src.resolve("m1/m1pro/");
    try (DirectoryStream<Path> stream = Files.newDirectoryStream(pkgdir, "*.java")) {
        for (Path entry : stream) {
            Files.deleteIfExists(entry);
        }
    } catch (DirectoryIteratorException ex) {
        // I/O error encounted during the iteration
        throw ex.getCause();
    }
    execTask("--module-source-path", src.toString(),
            "-subpackages", "m1/m1pro");

    checkPackagesSpecified("m1pro", "m1pro.pro1", "m1pro.pro2");

    // empty package directory should cause an error
    execNegativeTask("--module-source-path", src.toString(),
                     "m1/m1pro");

}

PollingWatchKey(Path dir, PollingWatchService watcher, Object fileKey)
    throws IOException
{
    super(dir, watcher);
    this.fileKey = fileKey;
    this.valid = true;
    this.tickCount = 0;
    this.entries = new HashMap<Path,CacheEntry>();

    // get the initial entries in the directory
    try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
        for (Path entry: stream) {
            // don't follow links
            long lastModified =
                Files.getLastModifiedTime(entry, LinkOption.NOFOLLOW_LINKS).toMillis();
            entries.put(entry.getFileName(), new CacheEntry(lastModified, tickCount));
        }
    } catch (DirectoryIteratorException e) {
        throw e.getCause();
    }
}

/**
 * Read a.yaml file according to a class type.
 *
 * @param path          folder which contain the config files
 * @param classType     Class type of the.yaml bean
 * @param fileNameRegex file name regex
 * @param <T>           Class T
 * @return Config file bean
 * @throws CarbonIdentityMgtConfigException Error in reading configuration file
 */
public static <T> List<T> readConfigFiles(Path path, Class<T> classType, String fileNameRegex)
        throws CarbonIdentityMgtConfigException {

    List<T> configEntries = new ArrayList<>();
    if (Files.exists(path)) {
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(path, fileNameRegex)) {
            for (Path file : stream) {
                Reader in = new InputStreamReader(Files.newInputStream(file), StandardCharsets.UTF_8);
                CustomClassLoaderConstructor constructor =
                        new CustomClassLoaderConstructor(classType.getClassLoader());
                Yaml yaml = new Yaml(constructor);
                yaml.setBeanAccess(BeanAccess.FIELD);
                configEntries.add(yaml.loadAs(in, classType));
            }
        } catch (DirectoryIteratorException | IOException e) {
            throw new CarbonIdentityMgtConfigException(String.format("Failed to read identity connector files " +
                    "from path: %s", path.toString()), e);
        }
    }
    return configEntries;
}

/**
 * Recurse down a directory tree, checking all child directories.
 * @param dir
 * @throws DiskErrorException
 */
public static void checkDirs(File dir) throws DiskErrorException {
  checkDir(dir);
  IOException ex = null;
  try (DirectoryStream<java.nio.file.Path> stream =
      Files.newDirectoryStream(dir.toPath())) {
    for (java.nio.file.Path entry: stream) {
      File child = entry.toFile();
      if (child.isDirectory()) {
        checkDirs(child);
      }
    }
  } catch (DirectoryIteratorException de) {
    ex = de.getCause();
  } catch (IOException ie) {
    ex = ie;
  }
  if (ex != null) {
    throw new DiskErrorException("I/O error when open a directory: "
        + dir.toString(), ex);
  }
}

/**
 * Return the complete list of files in a directory as strings.<p/>
 *
 * This is better than File#listDir because it does not ignore IOExceptions.
 *
 * @param dir              The directory to list.
 * @param filter           If non-null, the filter to use when listing
 *                         this directory.
 * @return                 The list of files in the directory.
 *
 * @throws IOException     On I/O error
 */
public static List<String> listDirectory(File dir, FilenameFilter filter)
    throws IOException {
  ArrayList<String> list = new ArrayList<String> ();
  try (DirectoryStream<Path> stream =
           Files.newDirectoryStream(dir.toPath())) {
    for (Path entry: stream) {
      String fileName = entry.getFileName().toString();
      if ((filter == null) || filter.accept(dir, fileName)) {
        list.add(fileName);
      }
    }
  } catch (DirectoryIteratorException e) {
    throw e.getCause();
  }
  return list;
}

/**
 * Return the complete list of files in a directory as strings.<p/>
 *
 * This is better than File#listDir because it does not ignore IOExceptions.
 *
 * @param dir              The directory to list.
 * @param filter           If non-null, the filter to use when listing
 *                         this directory.
 * @return                 The list of files in the directory.
 *
 * @throws IOException     On I/O error
 */
public static List<String> listDirectory(File dir, FilenameFilter filter)
    throws IOException {
  ArrayList<String> list = new ArrayList<String> ();
  try (DirectoryStream<Path> stream =
           Files.newDirectoryStream(dir.toPath())) {
    for (Path entry: stream) {
      String fileName = entry.getFileName().toString();
      if ((filter == null) || filter.accept(dir, fileName)) {
        list.add(fileName);
      }
    }
  } catch (DirectoryIteratorException e) {
    throw e.getCause();
  }
  return list;
}

public static File getRandomCasa(int size) {
    List<String> casas = new ArrayList<>();
    Path dir = Paths.get(Main.getPlugin().getDataFolder() + File.separator + "casas" + File.separator);
    if (Files.exists(dir)) {
        try(DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
            for (Path path : stream) {
                String fn = path.getFileName().toString().split(".schematic")[0];
                if (fn.split("-").length == 2) {
                    int smin = Integer.parseInt(fn.split("_")[1].split("-")[0]);
                    int smax = Integer.parseInt(fn.split("_")[1].split("-")[1]);
                    if (size >= smin && size <= smax) {
                        casas.add(path.getFileName().toString());
                    }
                }
            }
        } catch (IOException | DirectoryIteratorException e) {
            e.printStackTrace();
        }

        if (!casas.isEmpty()) {
            int i = new Random().nextInt(casas.size());
            return new File(dir.toString(), casas.get(i));
        }
    }
    return null;
}

/**
 * Resets the Mojo by setting {@link #mojo} to {@code null} and deletes the
 * test directory.
 *
 * @throws IOException Thrown if the test directory could not be deleted
 */
@After
public void tearDown() throws IOException {
    //Unset Mojo instance
    mojo = null;

    //Delete test directory
    final Path testDir = Paths.get(TEST_DIR);
    if (Files.exists(testDir)) {
        //First get all files in the test directory (if the test directory
        //exists and delete them. This is necessary because there is no
        //method for recursivly deleting a directory in the Java API.
        try (final DirectoryStream<Path> files = Files.newDirectoryStream(
            testDir)) {
            for (final Path file : files) {
                Files.deleteIfExists(file);
            }
        } catch (DirectoryIteratorException ex) {
            throw ex.getCause();
        }
        //Delete the (now empty) test directory.
        Files.deleteIfExists(testDir);
    }
}

/**
 * Resets the Mojo by setting {@link #mojo} to {@code null} and deletes the
 * test directory.
 *
 * @throws IOException Thrown if the test directory could not be deleted
 */
@After
public void tearDown() throws IOException {
    //Unset Mojo instance
    mojo = null;

    //Delete test directory
    final Path testDir = Paths.get(TEST_DIR);
    if (Files.exists(testDir)) {
        //First get all files in the test directory (if the test directory
        //exists and delete them. This is necessary because there is no
        //method for recursivly deleting a directory in the Java API.
        try (final DirectoryStream<Path> files = Files.newDirectoryStream(
            testDir)) {
            for (final Path file : files) {
                Files.deleteIfExists(file);
            }
        } catch (DirectoryIteratorException ex) {
            throw ex.getCause();
        }
        //Delete the (now empty) test directory.
        Files.deleteIfExists(testDir);
    }
}

/**
 * Resets the Mojo by setting {@link #mojo} to {@code null} and deletes the
 * test directory.
 *
 * @throws IOException Thrown if the test directory could not be deleted
 */
@After
public void tearDown() throws IOException {
    //Unset Mojo instance
    mojo = null;

    //Delete test directory
    final Path testDir = Paths.get(TEST_DIR);
    if (Files.exists(testDir)) {
        //First get all files in the test directory (if the test directory
        //exists and delete them. This is necessary because there is no
        //method for recursivly deleting a directory in the Java API.
        try (final DirectoryStream<Path> files = Files.newDirectoryStream(
            testDir)) {
            for (final Path file : files) {
                Files.deleteIfExists(file);
            }
        } catch (DirectoryIteratorException ex) {
            throw ex.getCause();
        }
        //Delete the (now empty) test directory.
        Files.deleteIfExists(testDir);
    }
}

/**
 * Return the complete list of files in a directory as strings.<p/>
 *
 * This is better than File#listDir because it does not ignore IOExceptions.
 *
 * @param dir              The directory to list.
 * @param filter           If non-null, the filter to use when listing
 *                         this directory.
 * @return                 The list of files in the directory.
 *
 * @throws IOException     On I/O error
 */
public static List<String> listDirectory(File dir, FilenameFilter filter)
    throws IOException {
  ArrayList<String> list = new ArrayList<String> ();
  try (DirectoryStream<Path> stream =
           Files.newDirectoryStream(dir.toPath())) {
    for (Path entry: stream) {
      String fileName = entry.getFileName().toString();
      if ((filter == null) || filter.accept(dir, fileName)) {
        list.add(fileName);
      }
    }
  } catch (DirectoryIteratorException e) {
    throw e.getCause();
  }
  return list;
}

private static Map<String, Collection<Path>> collectPlotFiles(List<String> plotDirectories, String numericAccountId)
{
  Map<String, Collection<Path>> plotFilesLookup = new HashMap<>();
  for(String plotDirectory : plotDirectories)
  {
    Path folderPath = Paths.get(plotDirectory);
    try (DirectoryStream<Path> plotFilesStream = Files.newDirectoryStream(folderPath))
    {
      List<Path> plotFilePaths = new ArrayList<>();
      for(Path plotFilePath : plotFilesStream)
      {
        if(plotFilePath.toString().contains(numericAccountId))
        {
          plotFilePaths.add(plotFilePath);
        }
      }
      plotFilesLookup.put(plotDirectory, plotFilePaths);
    }
    catch(IOException | DirectoryIteratorException e)
    {
      LOG.error(e.getMessage());
    }
  }
  return plotFilesLookup;
}

/**
 * Return the complete list of files in a directory as strings.<p/>
 *
 * This is better than File#listDir because it does not ignore IOExceptions.
 *
 * @param dir              The directory to list.
 * @param filter           If non-null, the filter to use when listing
 *                         this directory.
 * @return                 The list of files in the directory.
 *
 * @throws IOException     On I/O error
 */
public static List<String> listDirectory(File dir, FilenameFilter filter)
    throws IOException {
  ArrayList<String> list = new ArrayList<String> ();
  try (DirectoryStream<Path> stream =
           Files.newDirectoryStream(dir.toPath())) {
    for (Path entry: stream) {
      String fileName = entry.getFileName().toString();
      if ((filter == null) || filter.accept(dir, fileName)) {
        list.add(fileName);
      }
    }
  } catch (DirectoryIteratorException e) {
    throw e.getCause();
  }
  return list;
}

private static List<Path> listFiles(Path dir)
{
    if ((dir != null) && Files.isDirectory(dir)) {
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
            ImmutableList.Builder<Path> builder = ImmutableList.builder();
            for (Path file : stream) {
                builder.add(file);
            }

            return builder.build();
        }
        catch (IOException | DirectoryIteratorException x) {
            log.warn(x, "Warning.");
            throw Throwables.propagate(x);
        }
    }
    return ImmutableList.of();
}

private boolean fillContentList(Path dir) {
    contentlist.clear();

    // add parent path only if possible
    Path parentPath = dir.getParent();
    if (parentPath != null) {
        contentlist.add(new PathFixture(parentPath));
    }

    if (dir != null && Files.isDirectory(dir)) {
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
            for (Path entry : stream) {
                contentlist.add(new PathFixture(entry));
            }
        }
        catch (DirectoryIteratorException | IOException ex) {
            log.warn(ex.getMessage());
        }

    }

    return (contentlist.size() >= 1 ? true : false);
}

@Override
protected synchronized Path computeNext() {
  checkOpen();

  try {
    if (fileNames == null) {
      fileNames = view.snapshotWorkingDirectoryEntries().iterator();
    }

    while (fileNames.hasNext()) {
      Name name = fileNames.next();
      Path path = view.getWorkingDirectoryPath().resolve(name);

      if (filter.accept(path)) {
        return path;
      }
    }

    return endOfData();
  } catch (IOException e) {
    throw new DirectoryIteratorException(e);
  }
}

/**
 * @param dirStructure the directory structure the destination should adhere to 
* @param sourcePath the path to the files to move
 * @param destinationPath the path to where the files should be moved
 */
public FileMover(DirectoryStructure dirStructure, String sourcePath, String destinationPath) {
    this.dirStructure = dirStructure;
    this.sourcePath = sourcePath;
    this.destinationPath = destinationPath;
    this.verbose = false;

    Path sourceDir = Paths.get(this.sourcePath + "/");

    //Construct the list of all the files to move
    DirectoryStream<Path> stream;
    try {
        stream = Files.newDirectoryStream(sourceDir);
        for(Path currentFile : stream) {
            BasicFileAttributes fileAttributes = Files.readAttributes(currentFile, BasicFileAttributes.class);
            System.out.println(currentFile.toString());
            if(!fileAttributes.isDirectory() || Arrays.asList(getAppleFiles()).contains(getFileExtension(currentFile))) {
                this.filesToMove.add(currentFile);
            }
        }
    }
    catch(IOException | DirectoryIteratorException e) {
        System.err.println(e);
    }
}

private long countSubDirs(Path path) throws IOException {
    try (DirectoryStream<Path> ds = Files.newDirectoryStream(path, Files::isDirectory)) {
        return Iterables.size(ds);
    } catch (DirectoryIteratorException e) {
        throw new IOException(e);
    }
}

public int readdir(Path path, Pointer buf, FuseFillDir filler, long offset, FuseFileInfo fi) throws IOException {
        // fill in names and basic file attributes - however only the filetype is used...
//      Files.walkFileTree(node, EnumSet.noneOf(FileVisitOption.class), 1, new SimpleFileVisitor<Path>() {
//
//          @Override
//          public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
//              FileStat stat = attrUtil.basicFileAttributesToFileStat(attrs);
//              if (attrs.isDirectory()) {
//                  stat.st_mode.set(FileStat.S_IFDIR | FileStat.ALL_READ | FileStat.S_IXUGO);
//              } else {
//                  stat.st_mode.set(FileStat.S_IFREG | FileStat.ALL_READ);
//              }
//              filter.apply(buf, file.getFileName().toString(), stat, 0);
//              return FileVisitResult.CONTINUE;
//          }
//      });

        // just fill in names, getattr gets called for each entry anyway
        try (DirectoryStream<Path> ds = Files.newDirectoryStream(path)) {
            Iterator<Path> sameAndParent = Iterators.forArray(SAME_DIR, PARENT_DIR);
            Iterator<Path> iter = Iterators.concat(sameAndParent, ds.iterator());
            while (iter.hasNext()) {
                String fileName = iter.next().getFileName().toString();
                if (filler.apply(buf, fileName, null, 0) != 0) {
                    return -ErrorCodes.ENOMEM();
                }
            }
            return 0;
        } catch (DirectoryIteratorException e) {
            throw new IOException(e);
        }
    }

@Override
public Iterable<Path> children(Path dir) {
  if (Files.isDirectory(dir, NOFOLLOW_LINKS)) {
    try {
      return listFiles(dir);
    } catch (IOException e) {
      // the exception thrown when iterating a DirectoryStream if an I/O exception occurs
      throw new DirectoryIteratorException(e);
    }
  }
  return ImmutableList.of();
}

/**
 * Secure method for deleting the contents of a directory using {@code SecureDirectoryStream}.
 * Returns a collection of exceptions that occurred or null if no exceptions were thrown.
 */
@Nullable
private static Collection<IOException> deleteDirectoryContentsSecure(
    SecureDirectoryStream<Path> dir) {
  Collection<IOException> exceptions = null;
  try {
    for (Path path : dir) {
      exceptions = concat(exceptions, deleteRecursivelySecure(dir, path.getFileName()));
    }

    return exceptions;
  } catch (DirectoryIteratorException e) {
    return addException(exceptions, e.getCause());
  }
}

/**
 * Simple, insecure method for deleting the contents of a directory for file systems that don't
 * support {@code SecureDirectoryStream}. Returns a collection of exceptions that occurred or
 * null if no exceptions were thrown.
 */
@Nullable
private static Collection<IOException> deleteDirectoryContentsInsecure(
    DirectoryStream<Path> dir) {
  Collection<IOException> exceptions = null;
  try {
    for (Path entry : dir) {
      exceptions = concat(exceptions, deleteRecursivelyInsecure(entry));
    }

    return exceptions;
  } catch (DirectoryIteratorException e) {
    return addException(exceptions, e.getCause());
  }
}

private void listele()
{
   dtm.setRowCount(0);
    Path dir = Paths.get(txt_path.getText());
    try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
        for (Path file : stream) {

            dtm.addRow(new Object[]{file.getFileName()});
        }
    } catch (IOException | DirectoryIteratorException x) {

    }

}

public final static List<Path> listSourceFiles(Path dir, String wildcard) {
    List<Path> result = new ArrayList<>();
    try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, wildcard)) {
        for (Path entry : stream) {
            result.add(entry);
        }
    } catch (DirectoryIteratorException | IOException ex) {
        // I/O error encounted during the iteration, the cause is an
        // IOException
        ex.printStackTrace();
    }
    return result;
}

@Override
public Iterable<Path> children(Path dir) {
  if (Files.isDirectory(dir, NOFOLLOW_LINKS)) {
    try {
      return listFiles(dir);
    } catch (IOException e) {
      // the exception thrown when iterating a DirectoryStream if an I/O exception occurs
      throw new DirectoryIteratorException(e);
    }
  }
  return ImmutableList.of();
}

/**
 * Secure method for deleting the contents of a directory using {@code SecureDirectoryStream}.
 * Returns a collection of exceptions that occurred or null if no exceptions were thrown.
 */
@Nullable
private static Collection<IOException> deleteDirectoryContentsSecure(
    SecureDirectoryStream<Path> dir) {
  Collection<IOException> exceptions = null;
  try {
    for (Path path : dir) {
      exceptions = concat(exceptions, deleteRecursivelySecure(dir, path.getFileName()));
    }

    return exceptions;
  } catch (DirectoryIteratorException e) {
    return addException(exceptions, e.getCause());
  }
}

/**
 * Simple, insecure method for deleting the contents of a directory for file systems that don't
 * support {@code SecureDirectoryStream}. Returns a collection of exceptions that occurred or
 * null if no exceptions were thrown.
 */
@Nullable
private static Collection<IOException> deleteDirectoryContentsInsecure(
    DirectoryStream<Path> dir) {
  Collection<IOException> exceptions = null;
  try {
    for (Path entry : dir) {
      exceptions = concat(exceptions, deleteRecursivelyInsecure(entry));
    }

    return exceptions;
  } catch (DirectoryIteratorException e) {
    return addException(exceptions, e.getCause());
  }
}

private MCRPath getPath(MCRFilesystemNode[] children, int index) {
    try {
        MCRPath path = MCRPath.toMCRPath(mcrDirectoryStream.path.resolve(children[index].getName()));
        LOGGER.debug(() -> "getting path at index " + index + ": " + path);
        return path;
    } catch (RuntimeException e) {
        throw new DirectoryIteratorException(new IOException(e));
    }
}

private void deletarHistoricos() {
    Path p = Paths.get(getDataFolder() + File.separator + "checkbans");
    if (Files.exists(p)) {
        try(DirectoryStream<Path> stream = Files.newDirectoryStream(p)) {
            for (Path path : stream) {
                Files.delete(path);
            }
            Files.delete(p);
        } catch (IOException | DirectoryIteratorException e) {
            e.printStackTrace();
        }
    }
}

private static List<Path> listResFiles(Path dir, String pattern) throws IOException {
    List<Path> result = new ArrayList<>();
    try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, pattern)) {
        for (Path entry : stream) {
            result.add(entry);
        }
    } catch (DirectoryIteratorException ex) {
        throw ex.getCause();
    }
    return result;
}

public final static List<Path> listSourceFiles(Path dir, String wildcard) {
    List<Path> result = new ArrayList<>();
    try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, wildcard)) {
        for (Path entry : stream) {
            result.add(entry);
        }
    } catch (DirectoryIteratorException | IOException ex) {
        // I/O error encounted during the iteration, the cause is an
        // IOException
        ex.printStackTrace();
    }
    return result;
}

/**
 * Parse the files harvested from PoolParty and extract the
 * metadata.
 * @param pPprojectId The PoolParty project id.
 * @return The results of the metadata extraction.
 */
public final HashMap<String, Object> extractMetadata(
        final String pPprojectId) {
    Path dir = Paths.get(ToolkitFileUtils.getMetadataOutputPath(
            pPprojectId));
    HashMap<String, Object> results = new HashMap<String, Object>();
    ConceptHandler conceptHandler = new ConceptHandler();
    try (DirectoryStream<Path> stream =
            Files.newDirectoryStream(dir)) {
        for (Path entry: stream) {
            conceptHandler.setSource(entry.getFileName().toString());
            RDFFormat format = Rio.getParserFormatForFileName(
                    entry.toString());
            RDFParser rdfParser = Rio.createParser(format);
            rdfParser.setRDFHandler(conceptHandler);
            FileInputStream is = new FileInputStream(entry.toString());
            logger.debug("Reading RDF:" + entry.toString());
            rdfParser.parse(is, entry.toString());
        }
    } catch (DirectoryIteratorException
            | IOException
            | RDFParseException
            | RDFHandlerException ex) {
        results.put(TaskStatus.EXCEPTION,
                "Exception in extractMetadata while Parsing RDF");
        logger.error("Exception in extractMetadata while Parsing RDF:",
                ex);
        return results;
    }
    results.putAll(conceptHandler.getMetadata());
    results.put("concept_count", Integer.toString(
            conceptHandler.getCountedConcepts()));
    return results;
}

@Override
   public void backupToArchive(RawDataBackup backup) throws IOException {
try (DirectoryStream<Path> stream = Files.newDirectoryStream(directory)) {
    for (Path file : stream) {
    String path = file.getFileName().toString();
    try (final OutputStream os = backup.newEntry(path)) {
        Files.copy(getDataDir().resolve(path), os);
    } finally {
        backup.closeEntry();
    }
    }
} catch (IOException | DirectoryIteratorException die) {
    LOG.error("Could not read directory: " + directory.toAbsolutePath().toString());
}
   }

public DirectoryStream<Path> newDirectoryStream( Path dir,
                                                 DirectoryStream.Filter<? super Path> filter ) throws IOException {
    final ArrayList<Path> list = map.get( dir );
    if( list == null ) {
        final ArrayList<Path> paths = map.computeIfAbsent( dir, ( d ) -> new ArrayList<>() );

        return java.nio.file.Files.newDirectoryStream( dir, ( file ) -> {
            paths.add( file );
            exists.put( file, true );
            return filter.accept( file );
        } );
    }

    return new DirectoryStream<Path>() {
        @Override
        public Iterator<Path> iterator() {
            return Iterators.filter( list.iterator(), ( p ) -> {
                try {
                    return filter.accept( p );
                } catch( IOException e ) {
                    throw new DirectoryIteratorException( e );
                }
            } );
        }

        @Override
        public void close() throws IOException {

        }
    };
}

/**
 * Update the application file with the content from the update directory.
 * @param applicationFile The application file to be updated
 * @param updateDir The update directory holding the new file versions
 * @param removeUpdateFiles If true, the updated files are deleted from the update directory
 * @return The path to the newly updated application file, or null if there was no update performed
 * @throws IOException In case of an error
 */
public static Path update(Path applicationFile, Path updateDir, boolean removeUpdateFiles) throws IOException {
    Path newApplicationJar = null;
    // Extract the application name from the application file
    String applicationName = applicationFile.getFileName().toString();
    // Strip the extension
    applicationName = applicationName.substring(0, applicationName.lastIndexOf("."));

    ArrayList<Path> updateFiles = new ArrayList<>();
    try (DirectoryStream<Path> stream = Files.newDirectoryStream(updateDir, applicationName + "*.{jar,JAR,war,WAR,rar,RAR,ear,EAR}")) {
        for (Path entry : stream) {
            updateFiles.add(entry);
        }
    } catch (DirectoryIteratorException ex) {
        // I/O error encounted during the iteration, the cause is an IOException
        throw ex.getCause();
    }

    if (!updateFiles.isEmpty()) {
        Path updateFile = updateFiles.get(0);
        newApplicationJar = Files.copy(updateFile, applicationFile, StandardCopyOption.REPLACE_EXISTING);
        if (removeUpdateFiles) {
            Files.delete(updateFile);
        }
    }

    return newApplicationJar;
}

List<Path> listPhenotypeDataDirectories(Path dir) {
    List<Path> result = new ArrayList<>();
    try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
        for (Path entry : stream) {
            if (entry.toString().endsWith("_phenotype")) {
                logger.info("Found phenotype data directory {}", entry);
                result.add(entry);
            }
        }
    } catch (DirectoryIteratorException | IOException ex) {
        // I/O error encounted during the iteration, the cause is an IOException
        throw new UndefinedDataDirectoryException("Unable to read/find valid phenotype data directory");
    }
    return result;
}