org.apache.poi.poifs.storage: public class: BlockAllocationTableWriter

org.apache.poi.poifs.storage
public class: BlockAllocationTableWriter [javadoc | source]

java.lang.Object
   org.apache.poi.poifs.storage.BlockAllocationTableWriter

All Implemented Interfaces:
BlockWritable, BATManaged

This class manages and creates the Block Allocation Table, which is basically a set of linked lists of block indices.

Each block of the filesystem has an index. The first block, the header, is skipped; the first block after the header is index 0, the next is index 1, and so on.

A block's index is also its index into the Block Allocation Table. The entry that it finds in the Block Allocation Table is the index of the next block in the linked list of blocks making up a file, or it is set to -2: end of list.

author: Marc - Johnson (mjohnson at apache dot org)

Constructor:
public BlockAllocationTableWriter() { _start_block = POIFSConstants.END_OF_CHAIN; _entries = new IntList(); _blocks = new BATBlock[ 0 ]; } create a BlockAllocationTableWriter

Constructor:

 public BlockAllocationTableWriter() {
        _start_block = POIFSConstants.END_OF_CHAIN;
        _entries     = new IntList();
        _blocks      = new BATBlock[ 0 ];
}

create a BlockAllocationTableWriter

Method from org.apache.poi.poifs.storage.BlockAllocationTableWriter Summary:
allocateSpace, countBlocks, createBlocks, getStartBlock, setStartBlock, simpleCreateBlocks, writeBlocks

Methods from java.lang.Object:
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method from org.apache.poi.poifs.storage.BlockAllocationTableWriter Detail:
public int allocateSpace(int blockCount) { int startBlock = _entries.size(); if (blockCount > 0) { int limit = blockCount - 1; int index = startBlock + 1; for (int k = 0; k < limit; k++) { _entries.add(index++); } _entries.add(POIFSConstants.END_OF_CHAIN); } return startBlock; } Allocate space for a block of indices
public int countBlocks() { return _blocks.length; } Return the number of BigBlock's this instance uses
public int createBlocks() { int xbat_blocks = 0; int bat_blocks = 0; while (true) { int calculated_bat_blocks = BATBlock.calculateStorageRequirements(bat_blocks + xbat_blocks + _entries.size()); int calculated_xbat_blocks = HeaderBlockWriter .calculateXBATStorageRequirements(calculated_bat_blocks); if ((bat_blocks == calculated_bat_blocks) && (xbat_blocks == calculated_xbat_blocks)) { // stable ... we're OK break; } else { bat_blocks = calculated_bat_blocks; xbat_blocks = calculated_xbat_blocks; } } int startBlock = allocateSpace(bat_blocks); allocateSpace(xbat_blocks); simpleCreateBlocks(); return startBlock; } Create the BATBlocks we need
public int getStartBlock() { return _start_block; } get the starting block
public void setStartBlock(int start_block) { _start_block = start_block; } Set the start block for this instance
void simpleCreateBlocks() { _blocks = BATBlock.createBATBlocks(_entries.toArray()); } create the BATBlocks
public void writeBlocks(OutputStream stream) throws IOException { for (int j = 0; j < _blocks.length; j++) { _blocks[ j ].writeBlocks(stream); } } Write the storage to an OutputStream

Method from org.apache.poi.poifs.storage.BlockAllocationTableWriter Detail:

 public int allocateSpace(int blockCount) {
        int startBlock = _entries.size();
        if (blockCount  > 0)
        {
            int limit = blockCount - 1;
            int index = startBlock + 1;
            for (int k = 0; k <  limit; k++)
            {
                _entries.add(index++);
            }
            _entries.add(POIFSConstants.END_OF_CHAIN);
        }
        return startBlock;
}

Allocate space for a block of indices

 public int countBlocks() {
        return _blocks.length;
}

Return the number of BigBlock's this instance uses

 public int createBlocks() {
        int xbat_blocks = 0;
        int bat_blocks  = 0;
        while (true)
        {
            int calculated_bat_blocks  =
                BATBlock.calculateStorageRequirements(bat_blocks
                                                      + xbat_blocks
                                                      + _entries.size());
            int calculated_xbat_blocks =
                HeaderBlockWriter
                    .calculateXBATStorageRequirements(calculated_bat_blocks);
            if ((bat_blocks == calculated_bat_blocks)
                    && (xbat_blocks == calculated_xbat_blocks))
            {
                // stable ... we're OK
                break;
            }
            else
            {
                bat_blocks  = calculated_bat_blocks;
                xbat_blocks = calculated_xbat_blocks;
            }
        }
        int startBlock = allocateSpace(bat_blocks);
        allocateSpace(xbat_blocks);
        simpleCreateBlocks();
        return startBlock;
}

Create the BATBlocks we need

 public int getStartBlock() {
        return _start_block;
}

get the starting block

 public  void setStartBlock(int start_block) {
        _start_block = start_block;
}

Set the start block for this instance

  void simpleCreateBlocks() {
        _blocks = BATBlock.createBATBlocks(_entries.toArray());
}

create the BATBlocks

 public  void writeBlocks(OutputStream stream) throws IOException {
        for (int j = 0; j <  _blocks.length; j++)
        {
            _blocks[ j ].writeBlocks(stream);
        }
}

Write the storage to an OutputStream