public static int calcSize(int size) 
{
        return size * _block_size;
}

Calculate the storage size of a set of SmallDocumentBlocks

 public static SmallDocumentBlock[] convert(BlockWritable[] store,
    int size) throws IOException, ArrayIndexOutOfBoundsException 
{
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        for (int j = 0; j <  store.length; j++)
        {
            store[ j ].writeBlocks(stream);
        }
        byte[]               data = stream.toByteArray();
        SmallDocumentBlock[] rval =
            new SmallDocumentBlock[ convertToBlockCount(size) ];
        for (int index = 0; index <  rval.length; index++)
        {
            rval[ index ] = new SmallDocumentBlock(data, index);
        }
        return rval;
}

Factory for creating SmallDocumentBlocks from DocumentBlocks

 public static List extract(ListManagedBlock[] blocks) throws IOException 
{
        List sdbs = new ArrayList();
        for (int j = 0; j <  blocks.length; j++)
        {
            byte[] data = blocks[ j ].getData();
            for (int k = 0; k <  _blocks_per_big_block; k++)
            {
                sdbs.add(new SmallDocumentBlock(data, k));
            }
        }
        return sdbs;
}

create a list of SmallDocumentBlock's from raw data

 public static int fill(List blocks) 
{
        int count           = blocks.size();
        int big_block_count = (count + _blocks_per_big_block - 1)
                              / _blocks_per_big_block;
        int full_count      = big_block_count * _blocks_per_big_block;
        for (; count <  full_count; count++)
        {
            blocks.add(new SmallDocumentBlock());
        }
        return big_block_count;
}

fill out a List of SmallDocumentBlocks so that it fully occupies a set of big blocks

 public byte[] getData() throws IOException 
{
        return _data;
}

Get the data from the block

 public static  void read(BlockWritable[] blocks,
    byte[] buffer,
    int offset) 
{
        int firstBlockIndex  = offset / _block_size;
        int firstBlockOffset = offset % _block_size;
        int lastBlockIndex   = (offset + buffer.length - 1) / _block_size;
        if (firstBlockIndex == lastBlockIndex)
        {
            System.arraycopy(
                (( SmallDocumentBlock ) blocks[ firstBlockIndex ])._data,
                firstBlockOffset, buffer, 0, buffer.length);
        }
        else
        {
            int buffer_offset = 0;
            System.arraycopy(
                (( SmallDocumentBlock ) blocks[ firstBlockIndex ])._data,
                firstBlockOffset, buffer, buffer_offset,
                _block_size - firstBlockOffset);
            buffer_offset += _block_size - firstBlockOffset;
            for (int j = firstBlockIndex + 1; j <  lastBlockIndex; j++)
            {
                System.arraycopy((( SmallDocumentBlock ) blocks[ j ])._data,
                                 0, buffer, buffer_offset, _block_size);
                buffer_offset += _block_size;
            }
            System.arraycopy(
                (( SmallDocumentBlock ) blocks[ lastBlockIndex ])._data, 0,
                buffer, buffer_offset, buffer.length - buffer_offset);
        }
}

read data from an array of SmallDocumentBlocks

 public  void writeBlocks(OutputStream stream) throws IOException 
{
        stream.write(_data);
}

Write the data to an OutputStream