• 02.10.2002 - completely rewritten from original documents on sourceforge

This document is intended for Java developers who need to use the POIFS APIs to read, write, or modify files that employ a POIFS-compatible data structure to organize their content. It is not necessary for developers to understand the POIFS data structures, and an explanation of those data structures is beyond the scope of this document. It is expected that the members of the target audience will understand the rudiments of a hierarchical file system, and familiarity with the event pattern employed by Java APIs such as AWT would be helpful.

This document attempts to be consistent in its terminology, which is defined here:

In this technique for reading, the entire file system is loaded into memory, and the entire directory tree can be walked by an application, reading specific documents at the application's leisure.

// need an open InputStream; for a file-based system, this would be appropriate:
// InputStream stream = new FileInputStream(fileName);
POIFSFileSystem fs;
try
{
    fs = new POIFSFileSystem(inputStream);
}
catch (IOException e)
{
    // an I/O error occurred, or the InputStream did not provide a compatible
    // POIFS data structure
}
DirectoryEntry root = fs.getRoot();

// dir is an instance of DirectoryEntry ...
for (Iterator iter = dir.getEntries(); iter.hasNext(); )
{
    Entry entry = (Entry)iter.next();
    System.out.println("found entry: " + entry.getName());
    if (entry instanceof DirectoryEntry)
    {
        // .. recurse into this directory
    }
    else if (entry instanceof DocumentEntry)
    {
        // entry is a document, which you can read
    }
    else
    {
        // currently, either an Entry is a DirectoryEntry or a DocumentEntry,
	// but in the future, there may be other entry subinterfaces. The
	// internal data structure certainly allows for a lot more entry types.
    }
}

byte[] content = new byte[ stream.available() ];
stream.read(content);
stream.close();

// load file system
try
{
    DocumentInputStream stream = filesystem.createDocumentInputStream(documentName);
    // process data from stream
}
catch (IOException e)
{
    // no such document, or the Entry represented by documentName is not a
    // DocumentEntry
}

DocumentEntry document = (DocumentEntry)directory.getEntry(documentName);
DocumentInputStream stream = new DocumentInputStream(document);

The event-driven API for reading documents is a little more complicated and requires that your application know, in advance, which files it wants to read. The benefit of using this API is that each document is in memory just long enough for your application to read it, and documents that you never read at all are not in memory at all. When you're finished reading the documents you wanted, the file system has no data structures associated with it at all and can be discarded.

POIFSReader reader = new POIFSReader();
// register for everything
reader.registerListener(myOmnivorousListener);
// register for selective files
reader.registerListener(myPickyListener, "foo");
reader.registerListener(myPickyListener, "bar");
// register for selective files
reader.registerListener(myOtherPickyListener, new POIFSDocumentPath(),
     "fubar");
reader.registerListener(myOtherPickyListener, new POIFSDocumentPath(
    new String[] { "usr", "bin" ), "fubar");

POIFSFileSystem fs = new POIFSFileSystem();

There are two restrictions on the names of files in a file system that must be considered when creating files:

1. The name of the file must not exceed 31 characters. If it does, the POIFS API will silently truncate the name to fit.
2. The name of the file must be unique within its containing directory. This seems pretty obvious, but if it isn't spelled out, there'll be hell to pay, to be sure. Uniqueness, of course, is determined after the name has been truncated, if the original name was too long to begin with.

A document can be created by acquiring a DirectoryEntry and calling one of the two createDocument methods:

Unlike reading, you don't have to choose between the in-memory and event-driven writing models; both can co-exist in the same file system.

Writing is initiated when the POIFSFileSystem instance's writeFilesystem() method is called with an OutputStream to write to.

The event-driven model is quite similar to the event-driven model for reading, in that the file system calls your org.apache.poi.poifs.filesystem.POIFSWriterListener when it's time to write your document, just as the POIFSReader calls your POIFSReaderListener when it's time to read your document. Internally, when writeFilesystem() is called, the final POIFS data structures are created and are written to the specified OutputStream. When the file system needs to write a document out that was created with the event-driven model, it calls the POIFSWriterListener back, calling its processPOIFSWriterEvent() method, passing an org.apache.poi.poifs.filesystem.POIFSWriterEvent instance. This object contains the POIFSDocumentPath and name of the document, its size, and an open org.apache.poi.poifs.filesystem.DocumentOutputStream to which to write. A DocumentOutputStream is a wrapper over the OutputStream that was provided to the POIFSFileSystem to write to, and has the responsibility of making sure that the document your application writes fits within the size you specified for it.

Creating a directory is similar to creating a document, except that there's only one way to do so:

DirectoryEntry createdDir = existingDir.createDirectory(name);

As with reading documents, it is possible to create a new document or directory in the root directory by using convenience methods of POIFSFileSystem.

Removing a document is simple: you get the Entry corresponding to the document and call its delete() method. This is a boolean method, but should always return true, indicating that the operation succeeded.

Removing a directory is also simple: you get the Entry corresponding to the directory and call its delete() method. This is a boolean method, but, unlike deleting a document, may not always return true, indicating that the operation succeeded. Here are the reasons why the operation may fail:

• The directory still has files in it (to check, call isEmpty() on its DirectoryEntry; is the return value false?)
• The directory is the root directory. You cannot remove the root directory.

Regardless of whether the file is a directory or a document, it can be renamed, with one exception - the root directory has a special name that is expected by the components of a major software vendor's office suite, and the POIFS API will not let that name be changed. Renaming is done by acquiring the file's corresponding Entry instance and calling its renameTo method, passing in the new name.

Like delete, renameTo returns true if the operation succeeded, otherwise false. Reasons for failure include these:

• The new name is the same as another file in the same directory. And don't forget - if the new name is longer than 31 characters, it will be silently truncated. In its original length, the new name may have been unique, but truncated to 31 characters, it may not be unique any longer.
• You tried to rename the root directory.