public SmallBlockTable(List documents,
    RootProperty root) 
{
        _small_block_list = null;   // not used in this context
        _sbat             = new BlockAllocationTable();
        _small_blocks     = new ArrayList();
        _root             = root;
        Iterator iter = documents.iterator();
        while (iter.hasNext())
        {
            Document        doc    = ( Document ) iter.next();
            BlockWritable[] blocks = doc.getSmallBlocks();
            if (blocks.length != 0)
            {
                doc.setStartBlock(_sbat.allocateSpace(blocks.length));
                for (int j = 0; j <  blocks.length; j++)
                {
                    _small_blocks.add(blocks[ j ]);
                }
            }
        }
        _sbat.simpleCreateBlocks();
        _root.setSize(_small_blocks.size());
        _big_block_count = SmallDocumentBlock.fill(_small_blocks);
}

Creates new SmallBlockTable

Parameters:

documents - a List of Document instances

root - the Filesystem's root property

 public SmallBlockTable(RawDataBlockList blockList,
    RootProperty root,
    int sbatStart) throws IOException 
{
        _root = root;
        ListManagedBlock[] blocks =
            blockList.fetchBlocks(_root.getStartBlock());
        _big_block_count  = blocks.length;
        _small_blocks     = SmallDocumentBlock.extract(blocks);
        _small_block_list = new SmallDocumentBlockList(_small_blocks);
        _sbat             =
            new BlockAllocationTable(blockList.fetchBlocks(sbatStart),
                                     _small_block_list);
}

Acquire a SmallBlockTable from an existing file

Parameters:

blockList - the raw data from which the small block table will be extracted

root - the root property (which contains the start block and small block table size)

sbatStart - the start block of the SBAT

Throws:

IOException -

exception: IOException -

 public int countBlocks() 
{
        return _big_block_count;
}

Return the number of BigBlock's this instance uses

 public BlockAllocationTable getSBAT() 
{
        return _sbat;
}

Get the SBAT

 public BlockList getSmallDocumentBlocks() 
{
        return _small_block_list;
}

fetch the small document block list

 public  void setStartBlock(int start_block) 
{
        _root.setStartBlock(start_block);
}

Set the start block for this instance

 public  void writeBlocks(OutputStream stream) throws IOException 
{
        Iterator iter = _small_blocks.iterator();
        while (iter.hasNext())
        {
            (( BlockWritable ) iter.next()).writeBlocks(stream);
        }
}

Write the storage to an OutputStream