FileDocCategorySizeDatePackage
BATBlock.javaAPI DocApache Poi 3.0.17608Mon Jan 01 12:39:36 GMT 2007org.apache.poi.poifs.storage

BATBlock

public class BATBlock extends BigBlock
A block of block allocation table entries. BATBlocks are created only through a static factory method: createBATBlocks.
author
Marc Johnson (mjohnson at apache dot org)

Fields Summary
private static final int
_entries_per_block
private static final int
_entries_per_xbat_block
private static final int
_xbat_chain_offset
private static final byte
_default_value
private IntegerField[]
_fields
private byte[]
_data
Constructors Summary
private BATBlock()
Create a single instance initialized with default values


                 

     
    
        _data = new byte[ POIFSConstants.BIG_BLOCK_SIZE ];
        Arrays.fill(_data, _default_value);
        _fields = new IntegerField[ _entries_per_block ];
        int offset = 0;

        for (int j = 0; j < _entries_per_block; j++)
        {
            _fields[ j ] = new IntegerField(offset);
            offset       += LittleEndianConsts.INT_SIZE;
        }
    
private BATBlock(int[] entries, int start_index, int end_index)
Create a single instance initialized (perhaps partially) with entries

param
entries the array of block allocation table entries
param
start_index the index of the first entry to be written to the block
param
end_index the index, plus one, of the last entry to be written to the block (writing is for all index k, start_index <= k < end_index)

        this();
        for (int k = start_index; k < end_index; k++)
        {
            _fields[ k - start_index ].set(entries[ k ], _data);
        }
    
Methods Summary
public static intcalculateStorageRequirements(int entryCount)
Calculate how many BATBlocks are needed to hold a specified number of BAT entries.

param
entryCount the number of entries
return
the number of BATBlocks needed

        return (entryCount + _entries_per_block - 1) / _entries_per_block;
    
public static intcalculateXBATStorageRequirements(int entryCount)
Calculate how many XBATBlocks are needed to hold a specified number of BAT entries.

param
entryCount the number of entries
return
the number of XBATBlocks needed

        return (entryCount + _entries_per_xbat_block - 1)
               / _entries_per_xbat_block;
    
public static org.apache.poi.poifs.storage.BATBlock[]createBATBlocks(int[] entries)
Create an array of BATBlocks from an array of int block allocation table entries

param
entries the array of int entries
return
the newly created array of BATBlocks

        int        block_count = calculateStorageRequirements(entries.length);
        BATBlock[] blocks      = new BATBlock[ block_count ];
        int        index       = 0;
        int        remaining   = entries.length;

        for (int j = 0; j < entries.length; j += _entries_per_block)
        {
            blocks[ index++ ] = new BATBlock(entries, j,
                                             (remaining > _entries_per_block)
                                             ? j + _entries_per_block
                                             : entries.length);
            remaining         -= _entries_per_block;
        }
        return blocks;
    
public static org.apache.poi.poifs.storage.BATBlock[]createXBATBlocks(int[] entries, int startBlock)
Create an array of XBATBlocks from an array of int block allocation table entries

param
entries the array of int entries
param
startBlock the start block of the array of XBAT blocks
return
the newly created array of BATBlocks

        int        block_count =
            calculateXBATStorageRequirements(entries.length);
        BATBlock[] blocks      = new BATBlock[ block_count ];
        int        index       = 0;
        int        remaining   = entries.length;

        if (block_count != 0)
        {
            for (int j = 0; j < entries.length; j += _entries_per_xbat_block)
            {
                blocks[ index++ ] =
                    new BATBlock(entries, j,
                                 (remaining > _entries_per_xbat_block)
                                 ? j + _entries_per_xbat_block
                                 : entries.length);
                remaining         -= _entries_per_xbat_block;
            }
            for (index = 0; index < blocks.length - 1; index++)
            {
                blocks[ index ].setXBATChain(startBlock + index + 1);
            }
            blocks[ index ].setXBATChain(POIFSConstants.END_OF_CHAIN);
        }
        return blocks;
    
public static final intentriesPerBlock()

return
number of entries per block

        return _entries_per_block;
    
public static final intentriesPerXBATBlock()

return
number of entries per XBAT block

        return _entries_per_xbat_block;
    
public static final intgetXBATChainOffset()

return
offset of chain index of XBAT block

        return _xbat_chain_offset;
    
private voidsetXBATChain(int chainIndex)

        _fields[ _entries_per_xbat_block ].set(chainIndex, _data);
    
voidwriteData(java.io.OutputStream stream)
Write the block's data to an OutputStream

param
stream the OutputStream to which the stored data should be written
exception
IOException on problems writing to the specified stream

        doWriteData(stream, _data);