FileDocCategorySizeDatePackage
POIFSReader.javaAPI DocApache Poi 3.0.111014Mon Jan 01 12:39:36 GMT 2007org.apache.poi.poifs.eventfilesystem

POIFSReader

public class POIFSReader extends Object
An event-driven reader for POIFS file systems. Users of this class first create an instance of it, then use the registerListener methods to register POIFSReaderListener instances for specific documents. Once all the listeners have been registered, the read() method is called, which results in the listeners being notified as their documents are read.
author
Marc Johnson (mjohnson at apache dot org)

Fields Summary
private POIFSReaderRegistry
registry
private boolean
registryClosed
Constructors Summary
public POIFSReader()
Create a POIFSReader

        registry       = new POIFSReaderRegistry();
        registryClosed = false;
Methods Summary
public static voidmain(java.lang.String[] args)
read in files

param
args names of the files
exception
IOException

        if (args.length == 0)
        {
            System.err
                .println("at least one argument required: input filename(s)");
            System.exit(1);
        }

        // register for all
        for (int j = 0; j < args.length; j++)
        {
            POIFSReader         reader   = new POIFSReader();
            POIFSReaderListener listener = new SampleListener();

            reader.registerListener(listener);
            System.out.println("reading " + args[ j ]);
            FileInputStream istream = new FileInputStream(args[ j ]);

            reader.read(istream);
            istream.close();
        }
private voidprocessProperties(org.apache.poi.poifs.storage.BlockList small_blocks, org.apache.poi.poifs.storage.BlockList big_blocks, java.util.Iterator properties, org.apache.poi.poifs.filesystem.POIFSDocumentPath path)

        while (properties.hasNext())
        {
            Property property = ( Property ) properties.next();
            String   name     = property.getName();

            if (property.isDirectory())
            {
                POIFSDocumentPath new_path = new POIFSDocumentPath(path,
                                                 new String[]
                {
                    name
                });

                processProperties(
                    small_blocks, big_blocks,
                    (( DirectoryProperty ) property).getChildren(), new_path);
            }
            else
            {
                int      startBlock = property.getStartBlock();
                Iterator listeners  = registry.getListeners(path, name);

                if (listeners.hasNext())
                {
                    int           size     = property.getSize();
                    POIFSDocument document = null;

                    if (property.shouldUseSmallBlocks())
                    {
                        document =
                            new POIFSDocument(name, small_blocks
                                .fetchBlocks(startBlock), size);
                    }
                    else
                    {
                        document =
                            new POIFSDocument(name, big_blocks
                                .fetchBlocks(startBlock), size);
                    }
                    while (listeners.hasNext())
                    {
                        POIFSReaderListener listener =
                            ( POIFSReaderListener ) listeners.next();

                        listener.processPOIFSReaderEvent(
                            new POIFSReaderEvent(
                                new DocumentInputStream(document), path,
                                name));
                    }
                }
                else
                {

                    // consume the document's data and discard it
                    if (property.shouldUseSmallBlocks())
                    {
                        small_blocks.fetchBlocks(startBlock);
                    }
                    else
                    {
                        big_blocks.fetchBlocks(startBlock);
                    }
                }
            }
        }
public voidread(java.io.InputStream stream)
Read from an InputStream and process the documents we get

param
stream the InputStream from which to read the data
exception
IOException on errors reading, or on invalid data

        registryClosed = true;

        // read the header block from the stream
        HeaderBlockReader header_block_reader = new HeaderBlockReader(stream);

        // read the rest of the stream into blocks
        RawDataBlockList  data_blocks         = new RawDataBlockList(stream);

        // set up the block allocation table (necessary for the
        // data_blocks to be manageable
        new BlockAllocationTableReader(header_block_reader.getBATCount(),
                                       header_block_reader.getBATArray(),
                                       header_block_reader.getXBATCount(),
                                       header_block_reader.getXBATIndex(),
                                       data_blocks);

        // get property table from the document
        PropertyTable properties =
            new PropertyTable(header_block_reader.getPropertyStart(),
                              data_blocks);

        // process documents
        processProperties(SmallBlockTableReader
            .getSmallDocumentBlocks(data_blocks, properties
                .getRoot(), header_block_reader
                    .getSBATStart()), data_blocks, properties.getRoot()
                        .getChildren(), new POIFSDocumentPath());
public voidregisterListener(org.apache.poi.poifs.eventfilesystem.POIFSReaderListener listener)
Register a POIFSReaderListener for all documents

param
listener the listener to be registered
exception
NullPointerException if listener is null
exception
IllegalStateException if read() has already been called

        if (listener == null)
        {
            throw new NullPointerException();
        }
        if (registryClosed)
        {
            throw new IllegalStateException();
        }
        registry.registerListener(listener);
public voidregisterListener(org.apache.poi.poifs.eventfilesystem.POIFSReaderListener listener, java.lang.String name)
Register a POIFSReaderListener for a document in the root directory

param
listener the listener to be registered
param
name the document name
exception
NullPointerException if listener is null or name is null or empty
exception
IllegalStateException if read() has already been called

        registerListener(listener, null, name);
public voidregisterListener(org.apache.poi.poifs.eventfilesystem.POIFSReaderListener listener, org.apache.poi.poifs.filesystem.POIFSDocumentPath path, java.lang.String name)
Register a POIFSReaderListener for a document in the specified directory

param
listener the listener to be registered
param
path the document path; if null, the root directory is assumed
param
name the document name
exception
NullPointerException if listener is null or name is null or empty
exception
IllegalStateException if read() has already been called

        if ((listener == null) || (name == null) || (name.length() == 0))
        {
            throw new NullPointerException();
        }
        if (registryClosed)
        {
            throw new IllegalStateException();
        }
        registry.registerListener(listener,
                                  (path == null) ? new POIFSDocumentPath()
                                                 : path, name);