public HeaderBlock() 
{
                 
        _data = new byte[ PoiFSConstants.BIG_BLOCK_SIZE ];
        Arrays.fill(_data, _default_value);
        new LongField(_signature_offset, _signature, _data);
        new IntegerField(0x08, 0, _data);
        new IntegerField(0x0c, 0, _data);
        new IntegerField(0x10, 0, _data);
        new IntegerField(0x14, 0, _data);
        new ShortField(0x18, ( short ) 0x3b, _data);
        new ShortField(0x1a, ( short ) 0x3, _data);
        new ShortField(0x1c, ( short ) -2, _data);
        new ShortField(0x1e, ( short ) 0x9, _data);
        new IntegerField(0x20, 0x6, _data);
        new IntegerField(0x24, 0, _data);
        new IntegerField(0x28, 0, _data);
        _bat_count      = new IntegerField(_bat_count_offset, 0, _data);
        _property_start = new IntegerField(_property_start_offset,
                                           PoiFSConstants.END_OF_CHAIN,
                                           _data);
        new IntegerField(0x34, 0, _data);
        new IntegerField(0x38, 0x1000, _data);
        _sbat_start = new IntegerField(_sbat_start_offset,
                                       PoiFSConstants.END_OF_CHAIN, _data);
        new IntegerField(0x40, 1, _data);
        _xbat_start = new IntegerField(_xbat_start_offset,
                                       PoiFSConstants.END_OF_CHAIN, _data);
        _xbat_count = new IntegerField(_xbat_count_offset, 0, _data);
}

Create a single instance initialized with default values

 public HeaderBlock(InputStream stream) throws IOException 
{
        _data = new byte[ PoiFSConstants.BIG_BLOCK_SIZE ];
        int byte_count = stream.read(_data);
        if (byte_count != PoiFSConstants.BIG_BLOCK_SIZE)
        {
            String type = " byte" + ((byte_count == 1) ? ("")
                                                       : ("s"));
            throw new IOException("Unable to read entire header; "
                                  + byte_count + type + " read; expected "
                                  + PoiFSConstants.BIG_BLOCK_SIZE + " bytes");
        }
        // verify signature
        LongField signature = new LongField(_signature_offset, _data);
        if (signature.get() != _signature)
        {
            throw new IOException("Invalid header signature; read "
                                  + signature.get() + ", expected "
                                  + _signature);
        }
        _bat_count      = new IntegerField(_bat_count_offset, _data);
        _property_start = new IntegerField(_property_start_offset, _data);
        _sbat_start     = new IntegerField(_sbat_start_offset, _data);
        _xbat_start     = new IntegerField(_xbat_start_offset, _data);
        _xbat_count     = new IntegerField(_xbat_count_offset, _data);
}

create a new HeaderBlock from an InputStream

Parameters:

stream - the source InputStream

Throws:

IOException - on errors or bad data

exception: IOException - on errors or bad data

 public static int calculateXBATStorageRequirements(int blockCount) 
{
        return (blockCount  > _max_bats_in_header)
               ? BATBlock.calculateXBATStorageRequirements(blockCount
                   - _max_bats_in_header)
               : 0;
}

For a given number of BAT blocks, calculate how many XBAT blocks will be needed

 public int[] getBATArray() 
{
        int[] result = new int[ _max_bats_in_header ];
        int   offset = _bat_array_offset;
        for (int j = 0; j <  _max_bats_in_header; j++)
        {
            result[ j ] = LittleEndian.getInt(_data, offset);
            offset      += LittleEndianConsts.INT_SIZE;
        }
        return result;
}

 public int getBATCount() 
{
        return _bat_count.get();
}

 public int getPropertyStart() 
{
        return _property_start.get();
}

get start of Property Table

 public int getSBATStart() 
{
        return _sbat_start.get();
}

 public int getXBATCount() 
{
        return _xbat_count.get();
}

 public int getXBATIndex() 
{
        return _xbat_start.get();
}

 public BATBlock[] setBATBlocks(int blockCount,
    int startBlock) 
{
        BATBlock[] rvalue;
        _bat_count.set(blockCount, _data);
        int limit  = Math.min(blockCount, _max_bats_in_header);
        int offset = _bat_array_offset;
        for (int j = 0; j <  limit; j++)
        {
            new IntegerField(offset, startBlock + j, _data);
            offset += LittleEndianConsts.INT_SIZE;
        }
        if (blockCount  > _max_bats_in_header)
        {
            int   excess_blocks      = blockCount - _max_bats_in_header;
            int[] excess_block_array = new int[ excess_blocks ];
            for (int j = 0; j <  excess_blocks; j++)
            {
                excess_block_array[ j ] = startBlock + j
                                          + _max_bats_in_header;
            }
            rvalue = BATBlock.createXBATBlocks(excess_block_array,
                                               startBlock + blockCount);
            _xbat_start.set(startBlock + blockCount, _data);
        }
        else
        {
            rvalue = BATBlock.createXBATBlocks(new int[ 0 ], 0);
            _xbat_start.set(PoiFSConstants.END_OF_CHAIN, _data);
        }
        _xbat_count.set(rvalue.length, _data);
        return rvalue;
}

Set BAT block parameters. Assumes that all BAT blocks are contiguous. Will construct XBAT blocks if necessary and return the array of newly constructed XBAT blocks.

 public  void setPropertyStart(int startBlock) 
{
        _property_start.set(startBlock, _data);
}

Set start of Property Table

 public  void setSBATStart(int startBlock) 
{
        _sbat_start.set(startBlock, _data);
}

Set start of small block allocation table

 public  void setXBATStart(int startBlock) 
{
        _xbat_start.set(startBlock, _data);
}

Set start of XBAT

  void writeData(OutputStream stream) throws IOException 
{
        doWriteData(stream, _data);
}

Write the block's data to an OutputStream