FlatDtdDataSet.java

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

  21. package org.dbunit.dataset.xml;

  22. import java.io.IOException;
  23. import java.io.InputStream;
  24. import java.io.OutputStream;
  25. import java.io.OutputStreamWriter;
  26. import java.io.Reader;
  27. import java.io.Writer;

  28. import org.dbunit.dataset.AbstractDataSet;
  29. import org.dbunit.dataset.DataSetException;
  30. import org.dbunit.dataset.DefaultTable;
  31. import org.dbunit.dataset.DefaultTableIterator;
  32. import org.dbunit.dataset.IDataSet;
  33. import org.dbunit.dataset.ITable;
  34. import org.dbunit.dataset.ITableIterator;
  35. import org.dbunit.dataset.ITableMetaData;
  36. import org.dbunit.dataset.NoSuchTableException;
  37. import org.dbunit.dataset.stream.IDataSetConsumer;
  38. import org.dbunit.dataset.stream.IDataSetProducer;
  39. import org.slf4j.Logger;
  40. import org.slf4j.LoggerFactory;
  41. import org.xml.sax.InputSource;

  42. /**
  43.  * @author Manuel Laflamme
  44.  * @author Last changed by: $Author$
  45.  * @version $Revision$ $Date$
  46.  * @since 1.0 (Apr 4, 2002)
  47.  */
  48. public class FlatDtdDataSet extends AbstractDataSet implements IDataSetConsumer
  49. {
  50.     private static final Logger logger = LoggerFactory.getLogger(FlatDtdDataSet.class);

  51.     private boolean _ready = false;

  52.     public FlatDtdDataSet()
  53.     {
  54.         initialize();
  55.     }

  56.     public FlatDtdDataSet(InputStream in) throws DataSetException, IOException
  57.     {
  58.         this(new FlatDtdProducer(new InputSource(in)));
  59.     }

  60.     public FlatDtdDataSet(Reader reader) throws DataSetException, IOException
  61.     {
  62.         this(new FlatDtdProducer(new InputSource(reader)));
  63.     }

  64.     public FlatDtdDataSet(IDataSetProducer producer) throws DataSetException
  65.     {
  66.         initialize();
  67.         producer.setConsumer(this);
  68.         producer.produce();
  69.     }

  70.     protected void initialize()
  71.     {
  72.         if(_orderedTableNameMap == null) {
  73.             _orderedTableNameMap = super.createTableNameMap();
  74.         }
  75.     }

  76.     /**
  77.      * Write the specified dataset to the specified output stream as DTD.
  78.      * @see FlatDtdWriter
  79.      */
  80.     public static void write(IDataSet dataSet, OutputStream out)
  81.             throws IOException, DataSetException
  82.     {
  83.         logger.debug("write(dataSet={}, out={}) - start", dataSet, out);
  84.         write(dataSet, new OutputStreamWriter(out));
  85.     }

  86.     /**
  87.      * Write the specified dataset to the specified writer as DTD.
  88.      * @see FlatDtdWriter
  89.      */
  90.     public static void write(IDataSet dataSet, Writer out)
  91.             throws IOException, DataSetException
  92.     {
  93.         logger.debug("write(dataSet={}, out={}) - start", dataSet, out);
  94.         FlatDtdWriter datasetWriter = new FlatDtdWriter(out);
  95.         datasetWriter.write(dataSet);
  96.     }

  97.     ////////////////////////////////////////////////////////////////////////////
  98.     // AbstractDataSet class

  99.     protected ITableIterator createIterator(boolean reversed)
  100.             throws DataSetException
  101.     {
  102.         logger.debug("createIterator(reversed={}) - start", reversed);

  103.         // Verify producer notifications completed
  104.         if (!_ready)
  105.         {
  106.             throw new IllegalStateException("Not ready!");
  107.         }

  108.         String[] names = _orderedTableNameMap.getTableNames();
  109.         ITable[] tables = new ITable[names.length];
  110.         for (int i = 0; i < names.length; i++)
  111.         {
  112.             String tableName = names[i];
  113.             ITable table = (ITable)_orderedTableNameMap.get(tableName);
  114.             if (table == null)
  115.             {
  116.                 throw new NoSuchTableException(tableName);
  117.             }

  118.             tables[i] = table;
  119.         }

  120.         return new DefaultTableIterator(tables, reversed);
  121.     }

  122.     ////////////////////////////////////////////////////////////////////////////
  123.     // IDataSet interface

  124.     public String[] getTableNames() throws DataSetException
  125.     {
  126.         logger.debug("getTableNames() - start");

  127.         // Verify producer notifications completed
  128.         if (!_ready)
  129.         {
  130.             throw new IllegalStateException("Not ready!");
  131.         }

  132.         return _orderedTableNameMap.getTableNames();
  133.     }

  134.     public ITableMetaData getTableMetaData(String tableName) throws DataSetException
  135.     {
  136.         logger.debug("getTableMetaData(tableName={}) - start", tableName);

  137.         // Verify producer notifications completed
  138.         if (!_ready)
  139.         {
  140.             throw new IllegalStateException("Not ready!");
  141.         }

  142.         return super.getTableMetaData(tableName);
  143.     }

  144.     public ITable getTable(String tableName) throws DataSetException
  145.     {
  146.         logger.debug("getTable(tableName={}) - start", tableName);

  147.         // Verify producer notifications completed
  148.         if (!_ready)
  149.         {
  150.             throw new IllegalStateException("Not ready!");
  151.         }

  152.         return super.getTable(tableName);
  153.     }

  154.     ////////////////////////////////////////////////////////////////////////
  155.     // IDataSetConsumer interface

  156.     public void startDataSet() throws DataSetException
  157.     {
  158.         logger.debug("startDataSet() - start");

  159.         _ready = false;
  160.     }

  161.     public void endDataSet() throws DataSetException
  162.     {
  163.         logger.debug("endDataSet() - start");

  164.         _ready = true;
  165.     }

  166.     public void startTable(ITableMetaData metaData) throws DataSetException
  167.     {
  168.         logger.debug("startTable(metaData={}) - start", metaData);

  169.         String tableName = metaData.getTableName();
  170.         _orderedTableNameMap.add(tableName, new DefaultTable(metaData));
  171.     }

  172.     public void endTable() throws DataSetException
  173.     {
  174.         // no op
  175.     }

  176.     public void row(Object[] values) throws DataSetException
  177.     {
  178.         // no op
  179.     }

  180.     public String toString()
  181.     {
  182.         final StringBuilder sb = new StringBuilder();
  183.         sb.append(getClass().getName()).append("[");
  184.         sb.append("_ready=").append(this._ready);
  185.         sb.append(", _orderedTableNameMap=").append(this._orderedTableNameMap);
  186.         sb.append("]");
  187.         return sb.toString();
  188.     }
  189. }