File	Doc	Category	Size	Date	Package
BlockAllocationTableReader.java	API Doc	Apache Poi 3.0.1	9290	Mon Jan 01 12:39:36 GMT 2007	org.apache.poi.poifs.storage

BlockAllocationTableReader

• java.lang.Object

Fields Summary
private IntList	_entries

Constructors Summary
public BlockAllocationTableReader(int block_count, int[] block_array, int xbat_count, int xbat_index, BlockList raw_block_list) create a BlockAllocationTableReader 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. param block_count the number of BAT blocks making up the block allocation table param block_array the array of BAT block indices from the filesystem's header param xbat_count the number of XBAT blocks param xbat_index the index of the first XBAT block param raw_block_list the list of RawDataBlocks exception IOException if, in trying to create the table, we encounter logic errors 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);
BlockAllocationTableReader(ListManagedBlock[] blocks, BlockList raw_block_list) create a BlockAllocationTableReader from an array of raw data blocks param blocks the raw data param raw_block_list the list holding the managed blocks exception IOException this(); setEntries(blocks, raw_block_list);
BlockAllocationTableReader() Constructor BlockAllocationTableReader _entries = new IntList();

Methods Summary
org.apache.poi.poifs.storage.ListManagedBlock[]	fetchBlocks(int startBlock, org.apache.poi.poifs.storage.BlockList blockList) walk the entries from a specified point and return the associated blocks. The associated blocks are removed from the block list param startBlock the first block in the chain param blockList the raw data block list return array of ListManagedBlocks, in their correct order exception IOException if there is a problem acquiring the blocks 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 ]);
int	getNextBlockIndex(int index) return the next block index param index of the current block return index of the next block (may be POIFSConstants.END_OF_CHAIN, indicating end of chain (duh)) exception IOException if the current block is unused if (isUsed(index)) { return _entries.get(index); } else { throw new IOException("index " + index + " is unused"); }
boolean	isUsed(int index) determine whether the block specified by index is used or not param index index of block in question return true if the specific block is used, else false boolean rval = false; try { rval = _entries.get(index) != -1; } catch (IndexOutOfBoundsException ignored) { } return rval;
private void	setEntries(org.apache.poi.poifs.storage.ListManagedBlock[] blocks, org.apache.poi.poifs.storage.BlockList raw_blocks) Convert an array of blocks into a set of integer indices param blocks the array of blocks containing the indices param raw_blocks the list of blocks being managed. Unused blocks will be eliminated from the list exception IOException int limit = BATBlock.entriesPerBlock(); for (int block_index = 0; block_index < blocks.length; block_index++) { byte[] data = blocks[ block_index ].getData(); int offset = 0; for (int k = 0; k < limit; k++) { int entry = LittleEndian.getInt(data, offset); if (entry == POIFSConstants.UNUSED_BLOCK) { raw_blocks.zap(_entries.size()); } _entries.add(entry); offset += LittleEndianConsts.INT_SIZE; } // discard block blocks[ block_index ] = null; } raw_blocks.setBAT(this);