Source for gnu.xml.validation.xmlschema.XMLSchemaSchemaFactory

   1: /* XMLSchemaSchemaFactory.java --
   2:    Copyright (C) 2006  Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: package gnu.xml.validation.xmlschema;
  39: 
  40: import java.io.IOException;
  41: import java.net.URL;
  42: import javax.xml.XMLConstants;
  43: import javax.xml.parsers.DocumentBuilder;
  44: import javax.xml.parsers.DocumentBuilderFactory;
  45: import javax.xml.parsers.ParserConfigurationException;
  46: import javax.xml.transform.Source;
  47: import javax.xml.transform.dom.DOMSource;
  48: import javax.xml.transform.stream.StreamSource;
  49: import javax.xml.validation.Schema;
  50: import javax.xml.validation.SchemaFactory;
  51: import org.relaxng.datatype.DatatypeException;
  52: import org.w3c.dom.Document;
  53: import org.w3c.dom.Node;
  54: import org.w3c.dom.ls.LSResourceResolver;
  55: import org.xml.sax.ErrorHandler;
  56: import org.xml.sax.InputSource;
  57: import org.xml.sax.SAXException;
  58: 
  59: /**
  60:  * Schema factory for W3C XML Schema schemata.
  61:  *
  62:  * @author <a href='mailto:dog@gnu.org'>Chris Burdess</a>
  63:  */
  64: public class XMLSchemaSchemaFactory
  65:   extends SchemaFactory
  66: {
  67: 
  68:   LSResourceResolver resourceResolver;
  69:   ErrorHandler errorHandler;
  70: 
  71:   public LSResourceResolver getResourceResolver()
  72:   {
  73:     return resourceResolver;
  74:   }
  75: 
  76:   public void setResourceResolver(LSResourceResolver resourceResolver)
  77:   {
  78:     this.resourceResolver = resourceResolver;
  79:   }
  80: 
  81:   public ErrorHandler getErrorHandler()
  82:   {
  83:     return this.errorHandler;
  84:   }
  85: 
  86:   public void setErrorHandler(ErrorHandler errorHandler)
  87:   {
  88:     this.errorHandler = errorHandler;
  89:   }
  90: 
  91: 
  92:   public boolean isSchemaLanguageSupported(String schemaLanguage)
  93:   {
  94:     return XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(schemaLanguage);
  95:   }
  96: 
  97:   public Schema newSchema()
  98:     throws SAXException
  99:   {
 100:     // TODO
 101:     throw new UnsupportedOperationException();
 102:   }
 103: 
 104:   public Schema newSchema(Source[] schemata)
 105:     throws SAXException
 106:   {
 107:     if (schemata == null || schemata.length != 1)
 108:       throw new IllegalArgumentException("must specify one source");
 109:     // TODO multiple sources
 110:     try
 111:       {
 112:         Document doc = getDocument(schemata[0]);
 113:         XMLSchemaBuilder builder = new XMLSchemaBuilder();
 114:         builder.parseSchema(doc);
 115:         return builder.schema;
 116:       }
 117:     catch (IOException e)
 118:       {
 119:         SAXException e2 = new SAXException(e.getMessage());
 120:         e2.initCause(e);
 121:         throw e2;
 122:       }
 123:     catch (DatatypeException e)
 124:       {
 125:         SAXException e2 = new SAXException(e.getMessage());
 126:         e2.initCause(e);
 127:         throw e2;
 128:       }
 129:   }
 130: 
 131:   private static Document getDocument(Source source)
 132:     throws SAXException, IOException
 133:   {
 134:     if (source instanceof DOMSource)
 135:       {
 136:         Node node = ((DOMSource) source).getNode();
 137:         if (node != null && node instanceof Document)
 138:           return (Document) node;
 139:       }
 140:     String url = source.getSystemId();
 141:     try
 142:       {
 143:         InputSource input = new InputSource(url);
 144:         if (source instanceof StreamSource)
 145:           {
 146:             StreamSource streamSource = (StreamSource) source;
 147:             input.setByteStream(streamSource.getInputStream());
 148:             input.setCharacterStream(streamSource.getReader());
 149:           }
 150:         if (input.getByteStream() == null &&
 151:             input.getCharacterStream() == null &&
 152:             url != null)
 153:           input.setByteStream(new URL(url).openStream());
 154:         DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
 155:         f.setNamespaceAware(true);
 156:         f.setCoalescing(true);
 157:         f.setExpandEntityReferences(true);
 158:         f.setIgnoringComments(true);
 159:         f.setIgnoringElementContentWhitespace(true);
 160:         DocumentBuilder b = f.newDocumentBuilder();
 161:         return b.parse(input);
 162:       }
 163:     catch (ParserConfigurationException e)
 164:       {
 165:         SAXException e2 = new SAXException(e.getMessage());
 166:         e2.initCause(e);
 167:         throw e2;
 168:       }
 169:   }
 170: 
 171: }