protected void copy(DirectoryEntry sourceDir, DirectoryEntry destDir) throws IOException {
for (org.apache.poi.poifs.filesystem.Entry entry : sourceDir) {
if (entry instanceof DirectoryEntry) {
// Need to recurse
DirectoryEntry newDir = destDir.createDirectory(entry.getName());
copy((DirectoryEntry) entry, newDir);
} else {
// Copy entry
InputStream contents = new DocumentInputStream((DocumentEntry) entry);
try {
destDir.createDocument(entry.getName(), contents);
} finally {
contents.close();
}
}
}
}
/**
* Ensures that the directory hierarchy for a document in a POI fileystem is in place. When a
* document is to be created somewhere in a POI filesystem its directory must be created first.
* This method creates all directories between the POI filesystem root and the directory the
* document should belong to which do not yet exist.
*
* <p>Unfortunately POI does not offer a simple method to interrogate the POIFS whether a
* certain child node (file or directory) exists in a directory. However, since we always start
* with an empty POIFS which contains the root directory only and since each directory in the
* POIFS is created by this method we can maintain the POIFS's directory hierarchy ourselves:
* The {@link DirectoryEntry} of each directory created is stored in a {@link Map}. The
* directories' path names map to the corresponding {@link DirectoryEntry} instances.
*
* @param poiFs The POI filesystem the directory hierarchy is created in, if needed.
* @param path The document's path. This method creates those directory components of this
* hierarchy which do not yet exist.
* @return The directory entry of the document path's parent. The caller should use this {@link
* DirectoryEntry} to create documents in it.
*/
public DirectoryEntry getPath(final POIFSFileSystem poiFs, final POIFSDocumentPath path) {
try {
/* Check whether this directory has already been created. */
final String s = path.toString();
DirectoryEntry de = (DirectoryEntry) paths.get(s);
if (de != null)
/* Yes: return the corresponding DirectoryEntry. */
return de;
/* No: We have to create the directory - or return the root's
* DirectoryEntry. */
int l = path.length();
if (l == 0)
/* Get the root directory. It does not have to be created
* since it always exists in a POIFS. */
de = poiFs.getRoot();
else {
/* Create a subordinate directory. The first step is to
* ensure that the parent directory exists: */
de = getPath(poiFs, path.getParent());
/* Now create the target directory: */
de = de.createDirectory(path.getComponent(path.length() - 1));
}
paths.put(s, de);
return de;
} catch (IOException ex) {
/* This exception will be thrown if the directory already
* exists. However, since we have full control about directory
* creation we can ensure that this will never happen. */
ex.printStackTrace(System.err);
throw new RuntimeException(ex.toString());
/* FIXME (2): Replace the previous line by the following once we
* no longer need JDK 1.3 compatibility. */
// throw new RuntimeException(ex);
}
}
