001    /*
002     * Copyright (C) 2008-2010 by Holger Arndt
003     *
004     * This file is part of the Universal Java Matrix Package (UJMP).
005     * See the NOTICE file distributed with this work for additional
006     * information regarding copyright ownership and licensing.
007     *
008     * UJMP is free software; you can redistribute it and/or modify
009     * it under the terms of the GNU Lesser General Public License as
010     * published by the Free Software Foundation; either version 2
011     * of the License, or (at your option) any later version.
012     *
013     * UJMP is distributed in the hope that it will be useful,
014     * but WITHOUT ANY WARRANTY; without even the implied warranty of
015     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
016     * GNU Lesser General Public License for more details.
017     *
018     * You should have received a copy of the GNU Lesser General Public
019     * License along with UJMP; if not, write to the
020     * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
021     * Boston, MA  02110-1301  USA
022     */
023    
024    package org.ujmp.core.io;
025    
026    
027    public class ImportMatrixXML {
028    
029    //      private XMLEventReader eventReader = null;
030    //
031    //      private XMLEvent currentEvent = null;
032    //
033    //      public ImportMatrixXML() {
034    //      }
035    //
036    //      public static final Matrix fromString(String string, Object... parameters)
037    //                      throws MatrixException, XMLStreamException {
038    //              StringReader sr = new StringReader(string);
039    //              IntelligentFileReader r = new IntelligentFileReader(sr);
040    //              Matrix m = fromReader(r, parameters);
041    //              r.close();
042    //              return m;
043    //      }
044    //
045    //      public static final Matrix fromStream(InputStream stream, Object... parameters)
046    //                      throws MatrixException, IOException, XMLStreamException {
047    //              InputStreamReader r = new InputStreamReader(stream);
048    //              Matrix m = fromReader(r, parameters);
049    //              r.close();
050    //              return m;
051    //      }
052    //
053    //      public static final Matrix fromFile(File file, Object... parameters) throws MatrixException,
054    //                      IOException, XMLStreamException {
055    //              FileReader lr = new FileReader(file);
056    //              Matrix m = fromReader(lr, parameters);
057    //              lr.close();
058    //              return m;
059    //      }
060    //
061    //      private void skipCharacters() throws XMLStreamException {
062    //              while (currentEvent.getEventType() == XMLEvent.CHARACTERS) {
063    //                      currentEvent = eventReader.nextEvent();
064    //                      // ignore
065    //              }
066    //      }
067    //
068    //      private void skipStartDocument() throws XMLStreamException {
069    //              if (currentEvent.getEventType() == XMLEvent.START_DOCUMENT) {
070    //                      currentEvent = eventReader.nextEvent();
071    //                      // ignore
072    //              }
073    //      }
074    //
075    //      private void skipStartTag() throws XMLStreamException {
076    //              if (currentEvent.getEventType() == XMLEvent.START_ELEMENT) {
077    //                      currentEvent = eventReader.nextEvent();
078    //                      // ignore
079    //              }
080    //      }
081    //
082    //      private void skipEndTag() throws XMLStreamException {
083    //              if (currentEvent.getEventType() == XMLEvent.END_ELEMENT) {
084    //                      currentEvent = eventReader.nextEvent();
085    //                      // ignore
086    //              }
087    //      }
088    //
089    //      private void skipInfo() throws XMLStreamException {
090    //              if ("info".equals(currentEvent.asStartElement().getName().getLocalPart())) {
091    //                      currentEvent = eventReader.nextEvent();
092    //                      skipCharacters();
093    //                      while (currentEvent.getEventType() != XMLEvent.END_ELEMENT) {
094    //                              skipStartTag();
095    //                              skipCharacters();
096    //                              skipEndTag();
097    //                              skipCharacters();
098    //                      }
099    //                      if ("info".equals(currentEvent.asEndElement().getName().getLocalPart())) {
100    //                              // ignore
101    //                              currentEvent = eventReader.nextEvent();
102    //                      } else {
103    //                              throw new MatrixException("xml does not have excected format: " + currentEvent);
104    //                      }
105    //              }
106    //      }
107    //
108    //      private void addCell(Matrix matrix) throws XMLStreamException {
109    //              if ("cell".equals(currentEvent.asStartElement().getName().getLocalPart())) {
110    //                      StartElement element = currentEvent.asStartElement();
111    //                      String po = element.getAttributeByName(new QName("pos")).getValue();
112    //                      long[] pos = Coordinates.parseString(po);
113    //                      currentEvent = eventReader.nextEvent();
114    //                      String s = currentEvent.asCharacters().getData();
115    //                      matrix.setAsObject(s, pos);
116    //                      currentEvent = eventReader.nextEvent();
117    //                      if (!"cell".equals(currentEvent.asEndElement().getName().getLocalPart())) {
118    //                              throw new MatrixException("xml does not have excected format: " + currentEvent);
119    //                      }
120    //                      currentEvent = eventReader.nextEvent();
121    //              }
122    //      }
123    //
124    //      private Matrix parseMatrix() throws XMLStreamException {
125    //              Matrix matrix = null;
126    //              if ("matrix".equals(currentEvent.asStartElement().getName().getLocalPart())) {
127    //                      StartElement element = currentEvent.asStartElement();
128    //                      String si = element.getAttributeByName(new QName("size")).getValue();
129    //                      String st = element.getAttributeByName(new QName("storageType")).getValue();
130    //                      String vt = element.getAttributeByName(new QName("valueType")).getValue();
131    //                      long[] size = Coordinates.parseString(si);
132    //                      ValueType valueType = ValueType.valueOf(vt);
133    //                      StorageType storageType = StorageType.valueOf(st);
134    //
135    //                      switch (storageType) {
136    //                      case SPARSE:
137    //                              matrix = MatrixFactory.sparse(valueType, size);
138    //                              break;
139    //                      default:
140    //                              matrix = MatrixFactory.dense(valueType, size);
141    //                              break;
142    //                      }
143    //
144    //                      currentEvent = eventReader.nextEvent();
145    //                      skipCharacters();
146    //                      skipInfo();
147    //                      skipCharacters();
148    //
149    //                      if (currentEvent.getEventType() == XMLEvent.START_ELEMENT
150    //                                      && "data".equals(currentEvent.asStartElement().getName().getLocalPart())) {
151    //                              currentEvent = eventReader.nextEvent();
152    //                              skipCharacters();
153    //                      } else {
154    //                              throw new MatrixException("xml does not have excected format: " + currentEvent);
155    //                      }
156    //
157    //                      while (currentEvent.getEventType() == XMLEvent.START_ELEMENT
158    //                                      && "cell".equals(currentEvent.asStartElement().getName().getLocalPart())) {
159    //                              addCell(matrix);
160    //                              skipCharacters();
161    //                      }
162    //
163    //                      if (!"data".equals(currentEvent.asEndElement().getName().getLocalPart())) {
164    //                              throw new MatrixException("xml does not have excected format: " + currentEvent);
165    //                      }
166    //
167    //                      currentEvent = eventReader.nextEvent();
168    //                      skipCharacters();
169    //
170    //                      if (!"matrix".equals(currentEvent.asEndElement().getName().getLocalPart())) {
171    //                              throw new MatrixException("xml does not have excected format: " + currentEvent);
172    //                      }
173    //
174    //              } else {
175    //                      throw new MatrixException("xml does not have excected format: " + currentEvent);
176    //              }
177    //              return matrix;
178    //      }
179    //
180    //      public Matrix read(Reader reader) throws MatrixException, XMLStreamException {
181    //              XMLInputFactory inputFactory = XMLInputFactory.newInstance();
182    //              eventReader = inputFactory.createXMLEventReader(reader);
183    //              currentEvent = eventReader.nextEvent();
184    //
185    //              skipCharacters();
186    //              skipStartDocument();
187    //              skipCharacters();
188    //              Matrix matrix = parseMatrix();
189    //
190    //              eventReader.close();
191    //
192    //              return matrix;
193    //      }
194    //
195    //      public static final Matrix fromReader(Reader reader, Object... parameters)
196    //                      throws MatrixException, XMLStreamException {
197    //              return new ImportMatrixXML().read(reader);
198    //
199    //      }
200    
201    }