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

create a BlockAllocationTable

 BlockAllocationTable(ListManagedBlock[] blocks,
    BlockList raw_block_list) throws IOException 
{
        this();
        setEntries(blocks, raw_block_list);
}

create a BlockAllocationTable from an array of raw data blocks

Parameters:

blocks - the raw data

raw_block_list - the list holding the managed blocks

Throws:

IOException -

exception: IOException -

 public BlockAllocationTable(int block_count,
    int[] block_array,
    int xbat_count,
    int xbat_index,
    BlockList raw_block_list) throws IOException 
{
        this();
        if (block_count < = 0)
        {
            throw new IOException(
                "Illegal block count; minimum count is 1, got " + block_count
                + " instead");
        }
        // acquire raw data blocks containing the BAT block data
        RawDataBlock blocks[] = new RawDataBlock[ block_count ];
        int          limit    = Math.min(block_count, block_array.length);
        int          block_index;
        for (block_index = 0; block_index <  limit; block_index++)
        {
            blocks[ block_index ] =
                ( RawDataBlock ) raw_block_list
                    .remove(block_array[ block_index ]);
        }
        if (block_index <  block_count)
        {
            // must have extended blocks
            if (xbat_index <  0)
            {
                throw new IOException(
                    "BAT count exceeds limit, yet XBAT index indicates no valid entries");
            }
            int chain_index           = xbat_index;
            int max_entries_per_block = BATBlock.entriesPerXBATBlock();
            int chain_index_offset    = BATBlock.getXBATChainOffset();
            for (int j = 0; j <  xbat_count; j++)
            {
                limit = Math.min(block_count - block_index,
                                 max_entries_per_block);
                byte[] data   = raw_block_list.remove(chain_index).getData();
                int    offset = 0;
                for (int k = 0; k <  limit; k++)
                {
                    blocks[ block_index++ ] =
                        ( RawDataBlock ) raw_block_list
                            .remove(LittleEndian.getInt(data, offset));
                    offset                  += LittleEndianConsts.INT_SIZE;
                }
                chain_index = LittleEndian.getInt(data, chain_index_offset);
                if (chain_index == PoiFSConstants.END_OF_CHAIN)
                {
                    break;
                }
            }
        }
        if (block_index != block_count)
        {
            throw new IOException("Could not find all blocks");
        }
        // now that we have all of the raw data blocks, go through and
        // create the indices
        setEntries(blocks, raw_block_list);
}

create a BlockAllocationTable for an existing filesystem. Side effect: when this method finishes, the BAT blocks will have been removed from the raw block list, and any blocks labeled as 'unused' in the block allocation table will also have been removed from the raw block list.

Parameters:

block_count - the number of BAT blocks making up the block allocation table

block_array - the array of BAT block indices from the filesystem's header

xbat_count - the number of XBAT blocks

xbat_index - the index of the first XBAT block

raw_block_list - the list of RawDataBlocks

Throws:

IOException - if, in trying to create the table, we encounter logic errors

exception: IOException - if, in trying to create the table, we encounter logic errors

 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;
}

Get the number of BAT blocks

 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 =
                HeaderBlock
                    .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

 ListManagedBlock[] fetchBlocks(int startBlock,
    BlockList blockList) throws IOException 
{
        List blocks       = new ArrayList();
        int  currentBlock = startBlock;
        while (currentBlock != PoiFSConstants.END_OF_CHAIN)
        {
            blocks.add(blockList.remove(currentBlock));
            currentBlock = _entries.get(currentBlock);
        }
        return ( ListManagedBlock [] ) blocks
            .toArray(new ListManagedBlock[ 0 ]);
}

walk the entries from a specified point and return the associated blocks. The associated blocks are removed from the block list

 int getNextBlockIndex(int index) throws IOException 
{
        if (isUsed(index))
        {
            return _entries.get(index);
        }
        else
        {
            throw new IOException("index " + index + " is unused");
        }
}

return the next block index

 public int getStartBlock() 
{
        return _start_block;
}

get the starting block

 boolean isUsed(int index) 
{
        boolean rval = false;
        try
        {
            rval = _entries.get(index) != -1;
        }
        catch (IndexOutOfBoundsException ignored)
        {
        }
        return rval;
}

determine whether the block specified by index is used or not

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

set the start block

  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