ReplacementDataSet.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;

  22. import org.slf4j.Logger;
  23. import org.slf4j.LoggerFactory;

  24. import java.util.HashMap;
  25. import java.util.Map;

  26. /**
  27.  * Decorator that replace configured values from the decorated dataset
  28.  * with replacement values.
  29.  *
  30.  * @author Manuel Laflamme
  31.  * @since Mar 17, 2003
  32.  * @version $Revision$
  33.  */
  34. public class ReplacementDataSet extends AbstractDataSet
  35. {

  36.     /**
  37.      * Logger for this class
  38.      */
  39.     private static final Logger logger = LoggerFactory.getLogger(ReplacementDataSet.class);

  40.     private final IDataSet _dataSet;
  41.     private final Map _objectMap;
  42.     private final Map _substringMap;
  43.     private String _startDelim;
  44.     private String _endDelim;
  45.     private boolean _strictReplacement;


  46.     /**
  47.      * Create a new ReplacementDataSet object that decorates the specified dataset.
  48.      *
  49.      * @param dataSet the decorated table
  50.      */
  51.     public ReplacementDataSet(IDataSet dataSet)
  52.     {
  53.         this(dataSet, new HashMap(), new HashMap());
  54.     }

  55.     /**
  56.      * Create a new ReplacementDataSet object that decorates the specified dataset.
  57.      *
  58.      * @param dataSet the decorated dataset
  59.      * @param objectMap the replacement objects mapping
  60.      * @param substringMap the replacement substrings mapping
  61.      */
  62.     public ReplacementDataSet(IDataSet dataSet, Map objectMap, Map substringMap)
  63.     {
  64.         super(dataSet.isCaseSensitiveTableNames());
  65.         _dataSet = dataSet;
  66.         _objectMap = objectMap == null ? new HashMap() : objectMap;
  67.         _substringMap = substringMap == null ? new HashMap() : substringMap;
  68.     }

  69.     /**
  70.      * Setting this property to true indicates that when no replacement
  71.      * is found for a delimited substring the replacement will fail fast.
  72.      *
  73.      * @param strictReplacement true if replacement should be strict
  74.      */
  75.     public void setStrictReplacement(boolean strictReplacement) {
  76.         this._strictReplacement = strictReplacement;
  77.     }
  78.    
  79.     /**
  80.      * Add a new Object replacement mapping.
  81.      *
  82.      * @param originalObject the object to replace
  83.      * @param replacementObject the replacement object
  84.      */
  85.     public void addReplacementObject(Object originalObject, Object replacementObject)
  86.     {
  87.         logger.debug("addReplacementObject(originalObject={}, replacementObject={}) - start", originalObject, replacementObject);

  88.         _objectMap.put(originalObject, replacementObject);
  89.     }

  90.     /**
  91.      * Add a new substring replacement mapping.
  92.      *
  93.      * @param originalSubstring the substring to replace
  94.      * @param replacementSubstring the replacement substring
  95.      */
  96.     public void addReplacementSubstring(String originalSubstring,
  97.             String replacementSubstring)
  98.     {
  99.         logger.debug("addReplacementSubstring(originalSubstring={}, replacementSubstring={}) - start", originalSubstring, replacementSubstring);

  100.         if (originalSubstring == null || replacementSubstring == null)
  101.         {
  102.             throw new NullPointerException();
  103.         }

  104.         _substringMap.put(originalSubstring, replacementSubstring);
  105.     }

  106.     /**
  107.      * Sets substring delimiters.
  108.      */
  109.     public void setSubstringDelimiters(String startDelimiter, String endDelimiter)
  110.     {
  111.         logger.debug("setSubstringDelimiters(startDelimiter={}, endDelimiter={}) - start", startDelimiter, endDelimiter);

  112.         if (startDelimiter == null || endDelimiter == null)
  113.         {
  114.             throw new NullPointerException();
  115.         }

  116.         _startDelim = startDelimiter;
  117.         _endDelim = endDelimiter;
  118.     }

  119.     private ReplacementTable createReplacementTable(ITable table)
  120.     {
  121.         logger.debug("createReplacementTable(table={}) - start", table);
  122.        
  123.         ReplacementTable replacementTable = new ReplacementTable(
  124.                 table, _objectMap, _substringMap, _startDelim, _endDelim);
  125.         replacementTable.setStrictReplacement(_strictReplacement);
  126.         return replacementTable;
  127.     }

  128.     ////////////////////////////////////////////////////////////////////////////
  129.     // AbstractDataSet class

  130.     protected ITableIterator createIterator(boolean reversed)
  131.             throws DataSetException
  132.     {
  133.         if(logger.isDebugEnabled())
  134.             logger.debug("createIterator(reversed={}) - start", String.valueOf(reversed));

  135.         return new ReplacementIterator(reversed ?
  136.                 _dataSet.reverseIterator() : _dataSet.iterator());
  137.     }

  138.     ////////////////////////////////////////////////////////////////////////////
  139.     // IDataSet interface

  140.     public String[] getTableNames() throws DataSetException
  141.     {
  142.         logger.debug("getTableNames() - start");

  143.         return _dataSet.getTableNames();
  144.     }

  145.     public ITableMetaData getTableMetaData(String tableName)
  146.             throws DataSetException
  147.     {
  148.         logger.debug("getTableMetaData(tableName={}) - start", tableName);

  149.         return _dataSet.getTableMetaData(tableName);
  150.     }

  151.     public ITable getTable(String tableName) throws DataSetException
  152.     {
  153.         logger.debug("getTable(tableName={}) - start", tableName);

  154.         return createReplacementTable(_dataSet.getTable(tableName));
  155.     }

  156.     ////////////////////////////////////////////////////////////////////////////
  157.     // ReplacementIterator class

  158.     private class ReplacementIterator implements ITableIterator
  159.     {

  160.         /**
  161.          * Logger for this class
  162.          */
  163.         private final Logger logger = LoggerFactory.getLogger(ReplacementIterator.class);

  164.         private final ITableIterator _iterator;

  165.         public ReplacementIterator(ITableIterator iterator)
  166.         {
  167.             _iterator = iterator;
  168.         }

  169.         ////////////////////////////////////////////////////////////////////////
  170.         // ITableIterator interface

  171.         public boolean next() throws DataSetException
  172.         {
  173.             logger.debug("next() - start");

  174.             return _iterator.next();
  175.         }

  176.         public ITableMetaData getTableMetaData() throws DataSetException
  177.         {
  178.             logger.debug("getTableMetaData() - start");

  179.             return _iterator.getTableMetaData();
  180.         }

  181.         public ITable getTable() throws DataSetException
  182.         {
  183.             logger.debug("getTable() - start");

  184.             return createReplacementTable(_iterator.getTable());
  185.         }
  186.     }
  187. }