public Filesystem() 
{
        _property_table = new PropertyTable();
        _documents      = new ArrayList();
        _root           = null;
}

Constructor, intended for writing

 public Filesystem(InputStream stream) throws IOException 
{
        this();
        // read the header block from the stream
        HeaderBlock      header_block = new HeaderBlock(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 BlockAllocationTable(header_block.getBATCount(),
                                 header_block.getBATArray(),
                                 header_block.getXBATCount(),
                                 header_block.getXBATIndex(), data_blocks);
        // get property table from the document
        PropertyTable   properties =
            new PropertyTable(header_block.getPropertyStart(), data_blocks);
        SmallBlockTable sbt        = new SmallBlockTable(data_blocks,
                                         properties.getRoot(),
                                         header_block.getSBATStart());
        // init documents
        processProperties(sbt.getSmallDocumentBlocks(), data_blocks,
                          properties.getRoot().getChildren(), null);
}

Create a Filesystem from an InputStream

Parameters:

stream - the InputStream from which to read the data

Throws:

IOException - on errors reading, or on invalid data

exception: IOException - on errors reading, or on invalid data

  void addDirectory(DirectoryProperty directory) 
{
        _property_table.addProperty(directory);
}

add a new DirectoryProperty

  void addDocument(Document document) 
{
        _documents.add(document);
        _property_table.addProperty(document.getDocumentProperty());
}

add a new Document

 public DirectoryEntry createDirectory(String name) throws IOException 
{
        return getRoot().createDirectory(name);
}

create a new DirectoryEntry in the root directory

 public DocumentEntry createDocument(InputStream stream,
    String name) throws IOException 
{
        return getRoot().createDocument(name, stream);
}

Create a new document to be added to the root directory

 public DocumentInputStream createDocumentInputStream(String documentName) throws IOException 
{
        Entry document = getRoot().getEntry(documentName);
        if (!document.isDocumentEntry())
        {
            throw new IOException("Entry '" + documentName
                                  + "' is not a DocumentEntry");
        }
        return new DocumentInputStream(( DocumentEntry ) document);
}

open a document in the root entry's list of entries

 public DirectoryEntry getRoot() 
{
        if (_root == null)
        {
            _root = new DirectoryNode(_property_table.getRoot(), this, null);
        }
        return _root;
}

get the root entry

 public static  void main(String[] args) throws IOException 
{
        if (args.length != 2)
        {
            System.err.println(
                "two arguments required: input filename and output filename");
            System.exit(1);
        }
        FileInputStream  istream = new FileInputStream(args[ 0 ]);
        FileOutputStream ostream = new FileOutputStream(args[ 1 ]);
        new Filesystem(istream).writeFilesystem(ostream);
        istream.close();
        ostream.close();
}

read in a file and write it back out again

  void remove(EntryNode entry) 
{
        _property_table.removeProperty(entry.getProperty());
        if (entry.isDocumentEntry())
        {
            _documents.remove((( DocumentNode ) entry).getDocument());
        }
}

remove an entry

 public  void writeFilesystem(OutputStream stream) throws IOException 
{
        // get the property table ready
        _property_table.preWrite();
        // create the small block store, and the SBAT
        SmallBlockTable      sbt        = new SmallBlockTable(_documents,
                                              _property_table.getRoot());
        // create the block allocation table
        BlockAllocationTable bat        = new BlockAllocationTable();
        // create a list of BATManaged objects: the documents plus the
        // property table and the small block table
        List                 bm_objects = new ArrayList();
        bm_objects.addAll(_documents);
        bm_objects.add(_property_table);
        bm_objects.add(sbt);
        bm_objects.add(sbt.getSBAT());
        // walk the list, allocating space for each and assigning each
        // a starting block number
        Iterator iter = bm_objects.iterator();
        while (iter.hasNext())
        {
            BATManaged bmo         = ( BATManaged ) iter.next();
            int        block_count = bmo.countBlocks();
            if (block_count != 0)
            {
                bmo.setStartBlock(bat.allocateSpace(block_count));
            }
            else
            {
                // Either the BATManaged object is empty or its data
                // is composed of SmallBlocks; in either case,
                // allocating space in the BAT is inappropriate
            }
        }
        // allocate space for the block allocation table and take its
        // starting block
        int         batStartBlock = bat.createBlocks();
        // get the extended block allocation table blocks
        HeaderBlock header_block  = new HeaderBlock();
        BATBlock[]  xbat_blocks   =
            header_block.setBATBlocks(bat.countBlocks(), batStartBlock);
        // set the property table start block
        header_block.setPropertyStart(_property_table.getStartBlock());
        // set the small block allocation table start block
        header_block.setSBATStart(sbt.getSBAT().getStartBlock());
        // the header is now properly initialized. Make a list of
        // writers (the header block, followed by the documents, the
        // property table, the small block store, the small block
        // allocation table, the block allocation table, and the
        // extended block allocation table blocks)
        List writers = new ArrayList();
        writers.add(header_block);
        writers.addAll(_documents);
        writers.add(_property_table);
        writers.add(sbt);
        writers.add(sbt.getSBAT());
        writers.add(bat);
        for (int j = 0; j <  xbat_blocks.length; j++)
        {
            writers.add(xbat_blocks[ j ]);
        }
        // now, write everything out
        iter = writers.iterator();
        while (iter.hasNext())
        {
            BlockWritable writer = ( BlockWritable ) iter.next();
            writer.writeBlocks(stream);
        }
}

Write the filesystem out