开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
WebRowSetDataProvider.java
资源名称：swingx.zip　[点击查看]
上传用户：zhengdagz
上传日期：2014-03-06
资源大小：1956k
文件大小：35k
源码类别：

xml/soap/webservice

开发平台：

Java

WebRowSetDataProvider.java：源码内容
  1. /*
  2.  * $Id: WebRowSetDataProvider.java,v 1.4 2005/10/15 11:43:20 pdoubleya Exp $
  3.  *
  4.  * Created on March 21, 2005, 9:52 AM
  5.  * Copyright 2005 Sun Microsystems, Inc., 4150 Network Circle,
  6.  * Santa Clara, California 95054, U.S.A. All rights reserved.
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Lesser General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2.1 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Lesser General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Lesser General Public
  19.  * License along with this library; if not, write to the Free Software
  20.  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21.  */
  23. package org.jdesktop.dataset.provider.sql;
  25. import java.io.InputStream;
  26. import java.io.InputStreamReader;
  27. import java.io.Reader;
  28. import java.math.BigDecimal;
  29. import java.math.BigInteger;
  30. import java.net.URL;
  31. import java.sql.SQLException;
  32. import java.sql.Timestamp;
  33. import java.sql.Types;
  34. import java.util.HashMap;
  35. import java.util.LinkedList;
  36. import java.util.List;
  37. import java.util.Map;
  38. import java.util.Stack;
  40. import javax.sql.RowSetMetaData;
  41. import javax.sql.rowset.RowSetMetaDataImpl;
  42. import javax.swing.SwingUtilities;
  43. import javax.xml.parsers.SAXParser;
  44. import javax.xml.parsers.SAXParserFactory;
  46. import org.jdesktop.dataset.DataColumn;
  47. import org.jdesktop.dataset.DataProvider;
  48. import org.jdesktop.dataset.DataRow;
  49. import org.jdesktop.dataset.DataTable;
  50. import org.jdesktop.dataset.event.TableChangeEvent;
  51. import org.jdesktop.dataset.provider.LoadTask;
  52. import org.jdesktop.dataset.provider.SaveTask;
  53. import org.jdesktop.dataset.provider.LoadTask.LoadItem;
  54. import org.xml.sax.Attributes;
  55. import org.xml.sax.InputSource;
  56. import org.xml.sax.SAXException;
  57. import org.xml.sax.XMLReader;
  58. import org.xml.sax.ext.LexicalHandler;
  59. import org.xml.sax.helpers.DefaultHandler;
  61. import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
  63. /**
  64.  * Takes webrowset XML and uses it to populate a DataTable. This particular
  65.  * DataProvider will drop all of the columns from the DataTable and add new
  66.  * columns back in based on the meta data in the XML.
  67.  *
  68.  * @author Richard Bair
  69.  */
  70. public class WebRowSetDataProvider extends DataProvider {
  71.     /**
  72.      * A static instance of the Factory used to parse documents in this WebRowSet implementation
  73.      */
  74.     private static final SAXParserFactory FACTORY = SAXParserFactory.newInstance();
  75.     
  76.     private URL url;
  77.     
  78.     private Runnable completionRunnable;
  79.     private Runnable metadataCompleteRunnable;
  80.     
  81.     /**
  82.      * Static initialization code for the FACTORY. Currently setting validating to false.
  83.      */
  84.     static {
  85.         FACTORY.setValidating(false);
  86.     }
  87.     
  88.     /** Creates a new instance of WebRowSetDataProvider */
  89.     public WebRowSetDataProvider() {
  90.     }
  91.     
  92.     protected SaveTask createSaveTask(DataTable[] tables) {
  93.         return new SaveTask(tables) {
  94.             protected void saveData(DataTable[] tables) throws Exception {}
  95.         };
  96.     }
  97.     
  98.     final class RowLoadItem {
  99.         public Object[] values;
  100.         public DataRow.DataRowStatus status;
  101.     }
  102.     
  103.     
  104.     protected LoadTask createLoadTask(DataTable[] tables) {
  105.         return new LoadTask(tables) {
  106.             
  107.             class WebRowSetXMLHandler extends DefaultHandler implements LexicalHandler {
  108.                 
  109.                 DataTable table;
  110.                 /**
  111.                  * List to keep track of rows that need to be loaded
  112.                  */
  113.                 private List dataToLoad = new LinkedList();
  114.                 /**
  115.                  * Stack to keep track of which tags have been seen
  116.                  */
  117.                 private Stack<String> tagStack = new Stack<String>();
  118.                 /**
  119.                  * Set to true if we have seen an opening "properties" tag, but not a closing.
  120.                  * inProperties, inMetaData, and inData are mutually exclusive
  121.                  */
  122.                 private boolean inProperties = false;
  123.                 /**
  124.                  * Set to true if we have seen an opening "metadata" tag, but not a closing.
  125.                  * inProperties, inMetaData, and inData are mutually exclusive
  126.                  */
  127.                 private boolean inMetaData = false;
  128.                 /**
  129.                  * Set to true if we have seen an opening "data" tag, but not a closing.
  130.                  * inProperties, inMetaData, and inData are mutually exclusive
  131.                  */
  132.                 private boolean inData = false;
  133.                 /**
  134.                  * The meta data object being updated. This metaData object is modified until the
  135.                  * closing "metadata" tag is found. Then the ShopLogicWebRowSet's meta data is updated
  136.                  * in one fell stroke
  137.                  */
  138.                 private RowSetMetaData metaData = null;
  139.                 /**
  140.                  * Keeps track of which column we are currently dealing with. This is used both by the
  141.                  * metadata parsing code, and the data parsing code
  142.                  */
  143.                 private int columnIndex = 1;
  144.                 /**
  145.                  * This is a stack of keyColumns parsed. After being parsed and added to this stack, they are
  146.                  * added to an int[] and set in the WebRowSet.
  147.                  */
  148.                 private Stack<Integer> keyColumnsStack = new Stack<Integer>();
  149.                 /**
  150.                  * Keeps track of the "type" value while parsing the type map.
  151.                  */
  152.                 private String mapType;
  153.                 /**
  154.                  * Keeps track of the "class" value while parsing the type map.
  155.                  */
  156.                 private String mapClass;
  157.                 /**
  158.                  * This is the map of types, as parsed from the file. After the closing "map" tag is found, the
  159.                  * WebRowSet is updated.
  160.                  */
  161.                 private Map<String,Class<?>> typeMap = new HashMap<String,Class<?>>();
  162.                 /**
  163.                  * Contains the data value parsed from the <code>characters</code> method. This is simply a string.
  164.                  * The <code>setValue</code> method is responsible for parsing this into an int, bool, etc.
  165.                  */
  166.                 private String data;
  167.                 /**
  168.                  * Keeps track of whether the last tag read was null.
  169.                  */
  170.                 private boolean wasNull;
  171.                 /**
  172.                  * This String is used while in the data portion of parsing. It is used as the first part of they
  173.                  * key in the cache for a row.
  174.                  */
  175.                 private String tableName = "";
  176.                 /**
  177.                  * This list maintains the rowValues as parsed from the file. After they are all parsed,
  178.                  * they are passed to the row.
  179.                  */
  180.                 private Object[] rowValues;
  181.                 /**
  182.                  * The index of the current row being processed. This is 1 based
  183.                  */
  184.                 private int currentRow = 0;
  185.                 
  186.                 
  187.                 public WebRowSetXMLHandler(DataTable table) {
  188.                     this.table = table;
  189.                 }
  190.                 
  191.                 public void comment(char[] ch, int start, int length)
  192.                 throws SAXException {
  193.                     
  194.                 }
  195.                 
  196.                 public void startCDATA()
  197.                 throws SAXException {
  198.                 }
  199.                 
  200.                 public void endCDATA()  throws SAXException {
  201.                 }
  202.                 
  203.                 public void startEntity(String name)
  204.                 throws SAXException {
  205.                 }
  206.                 
  207.                 public void endEntity(String name)
  208.                 throws SAXException {
  209.                 }
  210.                 
  211.                 public void startDTD(
  212.                         String name, String publicId, String systemId)
  213.                         throws SAXException {
  214.                 }
  215.                 
  216.                 public void endDTD()
  217.                 throws SAXException {
  218.                 }
  219.                 
  220.                 /**
  221.                  * Updates the <code>data</code> variable with the given characters using the default character set
  222.                  * @inheritDoc
  223.                  */
  224.                 public void characters(char[] ch, int start, int length) throws SAXException {
  225.                     //Remember that characters may be called multiple times for the same
  226.                     //element, so if data is null then the characters delivered here are
  227.                     //the data, otherwise append the characters to data
  228.                     if (data == null) {
  229.                         data = new String(ch, start, length);
  230.                     } else {
  231.                         data = data + new String(ch, start, length);
  232.                     }
  233.                     data = data.trim();
  234.                 }
  235.                 
  236.                 /**
  237.                  * Helper method that updates the current row at the given column with the given value.
  238.                  * This code actually determines the column type for the designated column, and uses that
  239.                  * information to transform the value into the proper data type. Data MAY be null
  240.                  * @param columnIndex
  241.                  * @param value
  242.                  * @throws Exception
  243.                  */
  244.                 private void setValue(int columnIndex, String value) throws Exception {
  245.                     //TODO Take into account the possiblity of a collision, and notify listeners if necessary
  246.                     if (wasNull || value == null) {
  247.                         rowValues[columnIndex - 1] = null;
  248.                     } else {
  249.                         switch (metaData.getColumnType(columnIndex)) {
  250.                             case Types.TINYINT:
  251.                                 rowValues[columnIndex - 1] = Byte.valueOf(value.trim());
  252.                                 break;
  253.                             case Types.SMALLINT:
  254.                                 rowValues[columnIndex - 1] = Short.valueOf(value.trim());
  255.                                 break;
  256.                             case Types.INTEGER:
  257.                                 rowValues[columnIndex - 1] = Integer.valueOf(value.trim());
  258.                                 break;
  259.                             case Types.BIGINT:
  260.                                 rowValues[columnIndex - 1] = Long.valueOf(value.trim());
  261.                                 break;
  262.                             case Types.REAL:
  263.                                 rowValues[columnIndex - 1] = Float.valueOf(value.trim());
  264.                                 break;
  265.                             case Types.FLOAT:
  266.                             case Types.DOUBLE:
  267.                                 rowValues[columnIndex - 1] = Double.valueOf(value.trim());
  268.                                 break;
  269.                             case Types.DECIMAL:
  270.                             case Types.NUMERIC:
  271.                                 rowValues[columnIndex - 1] = new BigDecimal(value.trim());
  272.                                 break;
  273.                             case Types.BOOLEAN:
  274.                             case Types.BIT:
  275.                                 rowValues[columnIndex - 1] = Boolean.valueOf(value.trim());
  276.                                 break;
  277.                             case Types.CHAR:
  278.                             case Types.VARCHAR:
  279.                             case Types.LONGVARCHAR:
  280.                                 rowValues[columnIndex - 1] = value;
  281.                                 break;
  282.                             case Types.VARBINARY:
  283.                             case Types.LONGVARBINARY:
  284.                             case Types.BINARY:
  285.                                 byte[] bytes = Base64.decode(value);
  286.                                 rowValues[columnIndex - 1] = bytes;
  287.                                 break;
  288.                             case Types.DATE:
  289.                             case Types.TIME:
  290.                             case Types.TIMESTAMP:
  291.                                 rowValues[columnIndex - 1] = new Timestamp(Long.parseLong(value.trim()));
  292.                                 break;
  293.                             case Types.ARRAY:
  294.                             case Types.BLOB:
  295.                             case Types.CLOB:
  296.                             case Types.DATALINK:
  297.                             case Types.DISTINCT:
  298.                             case Types.JAVA_OBJECT:
  299.                             case Types.OTHER:
  300.                             case Types.REF:
  301.                             case Types.STRUCT:
  302.                                 //what to do with this?
  303.                                 break;
  304.                             default :
  305.                                 //do nothing
  306.                         }
  307.                     }
  308.                 }
  309.                 
  310.                 /**
  311.                  * @inheritDoc
  312.                  */
  313.                 public void endDocument() throws SAXException {
  314.                     doLoad(table, dataToLoad);
  315.                     if (completionRunnable != null) {
  316.                         SwingUtilities.invokeLater(completionRunnable);
  317.                     }
  318.                 }
  319.                 
  320.                 /**
  321.                  * @inheritDoc
  322.                  */
  323.                 public void endElement(String uri, String localName, String qName) throws SAXException {
  324.                     if (tagStack.size() == 0) {
  325.                         return;
  326.                     }
  327.                     //get the last tag seen
  328.                     String tag = tagStack.pop();
  329.                     //handle each tag. Handle the data tags first since those will be called most frequently
  330.                     try {
  331.                         if (tag.equals("null")) {
  332.                             wasNull = true;
  333.                         } else if (tag.equals("columnvalue")) {
  334.                             //set the current column value
  335.                             setValue(columnIndex++, wasNull ? null : data);
  336.                         } else if (tag.equals("updatevalue")) {
  337.                             //set the update column value (the column to
  338.                             //apply the update to is the previous
  339.                             //columnIndex)
  340.                             setValue(columnIndex-1, wasNull ? null : data);
  341.                         } else if (tag.equals("currentrow")) {
  342.                             RowLoadItem loadItem = new RowLoadItem();
  343.                             loadItem.values = new Object[rowValues.length];
  344.                             System.arraycopy(rowValues, 0, loadItem.values, 0, rowValues.length);
  345.                             loadItem.status = DataRow.DataRowStatus.UNCHANGED;
  346.                             dataToLoad.add(loadItem);
  347.                         } else if (tag.equals("insertrow")) {
  348.                             RowLoadItem loadItem = new RowLoadItem();
  349.                             loadItem.values = new Object[rowValues.length];
  350.                             System.arraycopy(rowValues, 0, loadItem.values, 0, rowValues.length);
  351.                             loadItem.status = DataRow.DataRowStatus.INSERTED;
  352.                         } else if (tag.equals("deleterow")) {
  353.                             RowLoadItem loadItem = new RowLoadItem();
  354.                             loadItem.values = new Object[rowValues.length];
  355.                             System.arraycopy(rowValues, 0, loadItem.values, 0, rowValues.length);
  356.                             loadItem.status = DataRow.DataRowStatus.DELETED;
  357.                         } else if (tag.equals("modifyrow")) {
  358.                             RowLoadItem loadItem = new RowLoadItem();
  359.                             loadItem.values = new Object[rowValues.length];
  360.                             System.arraycopy(rowValues, 0, loadItem.values, 0, rowValues.length);
  361.                             loadItem.status = DataRow.DataRowStatus.UPDATED;
  362.                         }  else if (tag.equals("column")) {
  363.                             //in key-columns
  364.                             if (!wasNull) {
  365.                                 keyColumnsStack.push(new Integer(data.trim()));
  366.                             }
  367.                         } else if (tag.equals("type")) {
  368.                             mapType = wasNull ? null : data;
  369.                         } else if (tag.equals("class")) {
  370.                             mapClass = wasNull ? null : data;
  371.                             //add the type and class to the typeMap
  372.                             typeMap.put(mapType, mapClass == null ? null : Class.forName(mapClass));
  373.                         } else if (tag.equals("table-name")) {
  374.                             if (inProperties) {
  375. //                                        setTableName(wasNull ? null : data);
  376.                             } else if (inMetaData) {
  377.                                 metaData.setTableName(columnIndex, wasNull ? null : data);
  378.                             }
  379.                         } else if (tag.equals("column-count")) {
  380.                             metaData.setColumnCount(wasNull ? 0 : Integer.parseInt(data.trim()));
  381.                         } else if (tag.equals("column-index")) {
  382.                             columnIndex = Integer.parseInt(data.trim());
  383.                         } else if (tag.equals("key-columns")) {
  384.                             int[] kc = new int[keyColumnsStack.size()];
  385.                             int i = 0;
  386.                             for (Integer col : keyColumnsStack) {
  387.                                 kc[i++] = col.intValue();
  388.                             }
  389.                             try {
  390. //                                        setKeyColumns(kc);
  391.                             } catch (Exception e) {
  392.                                 e.printStackTrace();
  393. //                                        LOG.error("Failed to set the key columns, even after parsing. Columns were " + keyColumnsStack, e);
  394.                             }
  395.                         } else if (tag.equals("map")) {
  396.                             //if the tag was a map tag, then put the map
  397.                             // elements into the map
  398. //                                    setTypeMap(typeMap);
  399.                         } else if (tag.equals("auto-increment")) {
  400.                             metaData.setAutoIncrement(columnIndex, wasNull ? false : Boolean.parseBoolean(data));
  401.                         } else if (tag.equals("case-sensitive")) {
  402.                             metaData.setCaseSensitive(columnIndex, wasNull ? false : Boolean.parseBoolean(data));
  403.                         } else if (tag.equals("currency")) {
  404.                             metaData.setCurrency(columnIndex, wasNull ? false : Boolean.parseBoolean(data.trim()));
  405.                         } else if (tag.equals("nullable")) {
  406.                             metaData.setNullable(columnIndex, wasNull ? 0 : Integer.parseInt(data.trim()));
  407.                         } else if (tag.equals("signed")) {
  408.                             metaData.setSigned(columnIndex, wasNull ? false : Boolean.parseBoolean(data.trim()));
  409.                         } else if (tag.equals("searchable")) {
  410.                             metaData.setSearchable(columnIndex, wasNull ? false : Boolean.parseBoolean(data.trim()));
  411.                         } else if (tag.equals("column-display-size")) {
  412.                             metaData.setColumnDisplaySize(columnIndex, wasNull ? 255 : Integer.parseInt(data.trim()));
  413.                         } else if (tag.equals("column-label")) {
  414.                             metaData.setColumnLabel(columnIndex, wasNull ? null : data);
  415.                         } else if (tag.equals("column-name")) {
  416.                             metaData.setColumnName(columnIndex, data);
  417.                         } else if (tag.equals("schema-name")) {
  418.                             metaData.setSchemaName(columnIndex, wasNull ? null : data);
  419.                         } else if (tag.equals("column-precision")) {
  420.                             metaData.setPrecision(columnIndex, wasNull ? 0 : Integer.parseInt(data.trim()));
  421.                         } else if (tag.equals("column-scale")) {
  422.                             metaData.setScale(columnIndex, wasNull ? 0 : Integer.parseInt(data.trim()));
  423.                         } else if (tag.equals("catalog-name")) {
  424.                             metaData.setCatalogName(columnIndex, wasNull ? null : data);
  425.                         } else if (tag.equals("column-type")) {
  426.                             metaData.setColumnType(columnIndex, wasNull ? Types.VARCHAR : Integer.parseInt(data.trim()));
  427.                         } else if (tag.equals("column-type-name")) {
  428.                             metaData.setColumnTypeName(columnIndex, wasNull ? null : data);
  429.                         } else if (tag.equals("metadata")) {
  430.                             //drop all of the columns in the data table
  431.                             //and rebuild them based on this meta-data
  432.                             SwingUtilities.invokeAndWait(new Runnable() {
  433.                                 public void run() {
  434.                                     table.clear();
  435.                                     DataColumn[] cols = table.getColumns().toArray(new DataColumn[table.getColumns().size()]);
  436.                                     for (DataColumn col : cols) {
  437.                                         table.dropColumn(col.getName());
  438.                                     }
  439.                                     
  440.                                     //time to rebuild
  441.                                     try {
  442.                                         for (int i=0; i<metaData.getColumnCount(); i++) {
  443.                                             DataColumn col = table.createColumn(metaData.getColumnName(i+1));
  444.                                             switch (metaData.getColumnType(i+1)) {
  445.                                                 case Types.TINYINT:
  446.                                                     col.setType(Byte.class);
  447.                                                     break;
  448.                                                 case Types.SMALLINT:
  449.                                                     col.setType(Short.class);
  450.                                                     break;
  451.                                                 case Types.INTEGER:
  452.                                                     col.setType(Integer.class);
  453.                                                     break;
  454.                                                 case Types.BIGINT:
  455.                                                     col.setType(BigInteger.class);
  456.                                                     break;
  457.                                                 case Types.REAL:
  458.                                                     col.setType(Float.class);
  459.                                                     break;
  460.                                                 case Types.FLOAT:
  461.                                                 case Types.DOUBLE:
  462.                                                     col.setType(Double.class);
  463.                                                     break;
  464.                                                 case Types.DECIMAL:
  465.                                                 case Types.NUMERIC:
  466.                                                     col.setType(BigDecimal.class);
  467.                                                     break;
  468.                                                 case Types.BOOLEAN:
  469.                                                 case Types.BIT:
  470.                                                     col.setType(Boolean.class);
  471.                                                     break;
  472.                                                 case Types.CHAR:
  473.                                                 case Types.VARCHAR:
  474.                                                 case Types.LONGVARCHAR:
  475.                                                     col.setType(String.class);
  476.                                                     break;
  477.                                                 case Types.VARBINARY:
  478.                                                 case Types.LONGVARBINARY:
  479.                                                 case Types.BINARY:
  480.                                                     col.setType(Byte[].class);
  481.                                                     break;
  482.                                                 case Types.DATE:
  483.                                                 case Types.TIME:
  484.                                                 case Types.TIMESTAMP:
  485.                                                     col.setType(Timestamp.class);
  486.                                                     break;
  487.                                                 case Types.ARRAY:
  488.                                                 case Types.BLOB:
  489.                                                 case Types.CLOB:
  490.                                                 case Types.DATALINK:
  491.                                                 case Types.DISTINCT:
  492.                                                 case Types.JAVA_OBJECT:
  493.                                                 case Types.OTHER:
  494.                                                 case Types.REF:
  495.                                                 case Types.STRUCT:
  496.                                                     //what to do with this?
  497.                                                     break;
  498.                                                 default :
  499.                                                     //do nothing
  500.                                             }
  501.                                         }
  502.                                     } catch (Exception e) {
  503.                                         e.printStackTrace();
  504.                                     }
  505.                                     // TODO: new API
  506.                                     // table.fireDataTableChanged(new TableChangeEvent(table));
  507.                                     
  508.                                 }
  509.                             });
  510.                             if (metadataCompleteRunnable != null) {
  511.                                 SwingUtilities.invokeLater(metadataCompleteRunnable);
  512.                             }
  513.                         }
  514.                     } catch (Exception e) {
  515.                         e.printStackTrace();
  516. //                                LOG.error("Failed to parse something", e);
  517.                     }
  518.                     data = null;
  519.                     if (dataToLoad.size() >= 100) {
  520.                         doLoad(table, dataToLoad);
  521.                         dataToLoad = new LinkedList<RowLoadItem>();
  522.                     }
  523.                 }
  524.                 
  525.                 /**
  526.                  * @inheritDoc
  527.                  */
  528.                 public void startDocument() throws SAXException {
  529. //                            LOG.debug("Start of Document");
  530.                 }
  531.                 
  532.                 public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
  533.                     //reset the wasNull flag
  534.                     wasNull = false;
  535.                     //push the element name onto the stack. In this way, when
  536.                     // the characters method is called, I know what kind of data
  537.                     //I'm dealing with.
  538.                     String tag = qName.toLowerCase();
  539.                     tagStack.push(tag);
  540.                     try {
  541.                         if (tag.equals("properties")) {
  542.                             inProperties = true;
  543.                             inMetaData = false;
  544.                             inData = false;
  545.                         } else if (tag.equals("metadata")) {
  546.                             inProperties = false;
  547.                             inMetaData = true;
  548.                             inData = false;
  549.                             metaData = new RowSetMetaDataImpl();
  550.                         } else if (tag.equals("data")) {
  551.                             inProperties = false;
  552.                             inMetaData = false;
  553.                             inData = true;
  554.                             //construct the rowValues array
  555.                             rowValues = new Object[metaData.getColumnCount()];
  556.                         } else if (tag.equals("currentrow")) {
  557.                             columnIndex = 1;
  558.                             reinitRowValues();
  559.                             currentRow++;
  560.                         } else if (tag.equals("insertrow")) {
  561.                             columnIndex = 1;
  562.                             reinitRowValues();
  563.                             currentRow++;
  564.                         } else if (tag.equals("deleterow")) {
  565.                             columnIndex = 1;
  566.                             reinitRowValues();
  567.                             currentRow++;
  568.                         } else if (tag.equals("modifyrow")) {
  569.                             columnIndex = 1;
  570.                             reinitRowValues();
  571.                             currentRow++;
  572.                         }
  573.                     } catch (Exception e) {
  574.                         e.printStackTrace();
  575.                     }
  576.                 }
  577.                 
  578.                 /**
  579.                  * Utility method that clears out the rowValues array
  580.                  */
  581.                 private void reinitRowValues() {
  582.                     for (int i=0; i<rowValues.length; i++) {
  583.                         rowValues[i] = null;
  584.                     }
  585.                 }
  586.             }
  587.             
  588.             protected void loadData(LoadTask.LoadItem[] items) {
  589.                 for (LoadItem item : items) {
  590.                     DataTable table = item.table;
  591.                     List<RowLoadItem> loadItems = (List<RowLoadItem>)item.data;
  592.                     for (RowLoadItem loadItem : loadItems) {
  593.                         
  594.                         DataRow row = table.appendRowNoEvent();
  595.                         List<DataColumn> cols = table.getColumns();
  596.                         for (int i=0; i<loadItem.values.length; i++) {
  597.                             try {
  598.                                 row.setValue(cols.get(i).getName(), loadItem.values[i]);
  599.                             } catch (Exception e) {
  600.                                 System.out.println(loadItem.values.length);
  601.                             }
  602.                         }
  603.                         row.setStatus(loadItem.status);
  604.                         item.table.fireDataTableChanged(TableChangeEvent.newRowAddedEvent(item.table, row));
  605.                     }
  606.                     item.table.fireDataTableChanged(TableChangeEvent.newLoadCompleteEvent(item.table));
  607.                 }
  608.             }
  609.             
  610.             protected void readData(DataTable[] tables) throws Exception {
  611.                 //get the XML from the url
  612.                 try {
  613.                     for (int i=0; i<tables.length; i++) {
  614.                         InputStream is = url.openStream();
  615.                         readXml(new InputStreamReader(is), tables[i]);
  616.                     }
  617.                 } catch (Exception e) {
  618.                     e.printStackTrace();
  619.                 }
  620.             }
  621.             
  622.             public void doLoad(DataTable table, List items) {
  623.                 super.scheduleLoad(new LoadTask.LoadItem(table, items));
  624.             }
  625.             
  626.             /**
  627.              * Originally this method was implemented with a PullParser. However, the
  628.              * PullParser did not have very good error messages, so debugging the XML
  629.              * was murder. A normal SAX parser is being used at this time.
  630.              *
  631.              * @inheritDoc
  632.              */
  633.             public void readXml(Reader reader, final DataTable table) throws SQLException {
  634.                 try {
  635.                     /*
  636.                      * Parsing is done via SAX. The basic methodology is to keep a stack of tags seen.
  637.                      * Also, a flag is kept to keep track of whether or not a <null/> tag has been seen.
  638.                      * This flag is reset to false whenever a new tag is started, but is set to true when
  639.                      * the end of the <null> tag is found.
  640.                      * Also, A single variable contains the results of the character data for the current tag.
  641.                      * This variable is read after the end tag is found. You will find that all work is
  642.                      * done after the entire element has been read (after the end tag).
  643.                      */
  644.                     
  645.                     WebRowSetXMLHandler handler = new WebRowSetXMLHandler(table);
  646.                     SAXParser parser = FACTORY.newSAXParser();
  647.                     XMLReader xmlReader = parser.getXMLReader();
  648.                     xmlReader.setProperty(
  649.                             "http://xml.org/sax/properties/lexical-handler",
  650.                             handler
  651.                             );
  652.                     
  653.                     parser.parse(new InputSource(reader), handler );
  654.                 } catch (Exception e) {
  655.                     e.printStackTrace();
  656.                     throw new SQLException("Error while parsing a the xml document for a WebRowSetDataProvider");
  657.                 }
  658.             }
  659.         };
  660.         
  661.         
  662.     }
  663. /*
  664.     public static void main(String... args) {
  665.         DataSet ds = new DataSet();
  666.         DataTable dt = ds.createTable();
  667.         dt.setName("Rowset");
  668.         DataProvider dp = new WebRowSetDataProvider();
  669.         dt.setDataProvider(dp);
  670.         JFrame frame = new JFrame();
  671.     //   JTable table = new JTable();
  672.  //
  673.         //Binding b = BindingFactory.bind(table, dt);
  674.  
  675.         TabularDataModelAdapter adapter = new TabularDataModelAdapter(dt);
  676.  
  677.  
  678.      //   JNTable table = new JNTable();
  679.    //     new DirectTableBinding(table.getTable(),adapter);
  680.  
  681.         frame.getContentPane().setLayout(new BorderLayout());
  682.         frame.getContentPane().add(new JScrollPane(table), BorderLayout.CENTER);
  683.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  684.         frame.setSize(800,600);
  685.         frame.setVisible(true);
  686.         dt.load();
  687. //        dt.loadAndWait();
  688. //        System.out.println(dt.getRows().size());
  689. //        List<DataColumn> cols = dt.getColumns();
  690. //        for (DataColumn col : cols) {
  691. //            System.out.println(col.getName());
  692. //        }
  693.     }
  694.  
  695.  */
  696.     
  697.     public URL getUrl() {
  698.         return url;
  699.     }
  700.     
  701.     public void setUrl(URL url) {
  702.         this.url = url;
  703.     }
  704.     
  705.     public Runnable getCompletionRunnable() {
  706.         return completionRunnable;
  707.     }
  708.     
  709.     public void setCompletionRunnable(Runnable completionRunnable) {
  710.         this.completionRunnable = completionRunnable;
  711.     }
  712.     
  713.     public Runnable getMetadataCompleteRunnable() {
  714.         return metadataCompleteRunnable;
  715.     }
  716.     
  717.     public void setMetadataCompleteRunnable(Runnable metadataCompleteRunnable) {
  718.         this.metadataCompleteRunnable = metadataCompleteRunnable;
  719.     }
  720.     
  721.     
  722.     
  723. }