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

Calculate the storage size of a set of SmallDocumentBlocks

 public static SmallDocumentBlock[] convert(byte[] array,
    int size) 
{
        SmallDocumentBlock[] rval   =
            new SmallDocumentBlock[ (size + _block_size - 1) / _block_size ];
        int                  offset = 0;
        for (int k = 0; k <  rval.length; k++)
        {
            rval[ k ] = new SmallDocumentBlock();
            if (offset <  array.length)
            {
                int length = Math.min(_block_size, array.length - offset);
                System.arraycopy(array, offset, rval[ k ]._data, 0, length);
                if (length != _block_size)
                {
                    Arrays.fill(rval[ k ]._data, length, _block_size,
                                _default_fill);
                }
            }
            else
            {
                Arrays.fill(rval[ k ]._data, _default_fill);
            }
            offset += _block_size;
        }
        return rval;
}

convert a single long array into an array of SmallDocumentBlock instances

 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(makeEmptySmallDocumentBlock());
        }
        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 storage to an OutputStream