BufferedConsumer.java

/*
 *
 * The DbUnit Database Testing Framework
 * Copyright (C)2002-2004, DbUnit.org
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
package org.dbunit.dataset.stream;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.dbunit.dataset.Column;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.ITableMetaData;
import org.dbunit.dataset.xml.FlatXmlDataSet;

/**
 * Implementation of {@link IDataSetConsumer} which buffers all data
 * until the {@link #endDataSet()} event occurs.
 * This provides the possibility to append new {@link Column}s on
 * the fly which is needed for the column sensing feature in
 * {@link FlatXmlDataSet}.
 * 
 * @author gommma (gommma AT users.sourceforge.net)
 * @author Last changed by: $Author$
 * @version $Revision$ $Date$
 * @since 2.3.0
 */
public class BufferedConsumer implements IDataSetConsumer {

    private IDataSetConsumer _wrappedConsumer;
    
    /**
     * The table which is currently active
     */
    private TableBuffer _activeTable;
    /**
     * List that stores all {@link TableBuffer}s in a sorted fashion so that the 
     * table that was added first will also be flushed first when the {@link IDataSetConsumer}
     * is finally invoked.
     */
    private List _tableBuffers = new ArrayList();
    /**
     * Map that stores the table names as key and the {@link TableBuffer} as value
     */
    private Map _tableNames = new HashMap();
    
    
    /**
     * @param wrappedConsumer The consumer that is wrapped
     */
    public BufferedConsumer(IDataSetConsumer wrappedConsumer) 
    {
        if (wrappedConsumer == null) {
            throw new NullPointerException(
                    "The parameter '_wrappedConsumer' must not be null");
        }
        this._wrappedConsumer = wrappedConsumer;
    }
    
    public void startDataSet() throws DataSetException 
    {
        this._wrappedConsumer.startDataSet();
    }

    public void endDataSet() throws DataSetException 
    {
        // Flush out the whole collected dataset
        
        // Start the table with the final metadata
        for (Iterator iterator = _tableBuffers.iterator(); iterator.hasNext();) {
            TableBuffer entry = (TableBuffer) iterator.next();
            ITableMetaData metaData = (ITableMetaData) entry.getMetaData();
            
            this._wrappedConsumer.startTable(metaData);
            
            List dataRows = (List) entry.getDataRows();
            for (Iterator dataIterator = dataRows.iterator(); dataIterator.hasNext();) {
                Object[] rowValues = (Object[]) dataIterator.next();
                this._wrappedConsumer.row(rowValues);
            }
            // Clear the row data for this table finally
            dataRows.clear();
            
            this._wrappedConsumer.endTable();
        }

        // Finally notify consumer of the end of this DataSet
        this._wrappedConsumer.endDataSet();
    }

    public void row(Object[] values) throws DataSetException 
    {
        // Just collect/buffer the row
        this._activeTable.getDataRows().add(values);
    }

    public void startTable(ITableMetaData metaData) throws DataSetException 
    {
        // Do nothing here - we will buffer all data in the "row" method in order to write
        // them in the "endTable" method
        if(_tableNames.containsKey(metaData.getTableName()))
        {
            this._activeTable = (TableBuffer) _tableNames.get(metaData.getTableName());
            // overwrite the metadata with the new one which potentially contains new columns
            this._activeTable.setMetaData(metaData);
        }
        else
        {
            _activeTable = new TableBuffer(metaData);

            _tableBuffers.add(_activeTable);// add to the sorted list
            _tableNames.put(metaData.getTableName(), _activeTable);// add to the name map
        }
    }

    public void endTable() throws DataSetException 
    {
        if(this._activeTable == null) {
            throw new IllegalStateException("The field _activeMetaData must not be null at this stage");
        }

        Column[] columns = this._activeTable.getMetaData().getColumns();
        int finalColumnCount = columns.length;

        int rowCount = this._activeTable.getDataRows().size();
        // Fill up columns that were potentially missing in this row
        for (int i=0; i < rowCount; i++) {
            // Note that this only works when new columns are always added at the end to the _activeMetaData
            Object[] rowValues = (Object[]) this._activeTable.getDataRows().get(i);
            // If this row has less columns than final metaData, fill it up with "null"s so that it matches the length
            if(rowValues.length < finalColumnCount) {
                Object[] newRowValues = new Object[finalColumnCount];
                // Put in original values and leave all missing columns on "null"
                System.arraycopy(rowValues, 0, newRowValues, 0, rowValues.length);
                this._activeTable.getDataRows().set(i, newRowValues);
            }
        }
    }

    
    private static class TableBuffer
    {
        private ITableMetaData metaData;
        private final ArrayList dataRows;
        
        public TableBuffer(ITableMetaData metaData) {
            this(metaData, new ArrayList());
        }

        public TableBuffer(ITableMetaData metaData, ArrayList dataRows) {
            super();
            this.metaData = metaData;
            this.dataRows = dataRows;
        }

        public ITableMetaData getMetaData() {
            return metaData;
        }

        public void setMetaData(ITableMetaData metaData) {
            this.metaData = metaData;
        }

        public ArrayList getDataRows() {
            return dataRows;
        }

    }
}