| /* XMLSchemaValidatorHandler.java -- |
| Copyright (C) 2006 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| package gnu.xml.validation.xmlschema; |
| |
| import java.util.ArrayList; |
| import java.util.LinkedList; |
| import javax.xml.XMLConstants; |
| import javax.xml.namespace.QName; |
| import javax.xml.validation.TypeInfoProvider; |
| import javax.xml.validation.ValidatorHandler; |
| import org.relaxng.datatype.DatatypeException; |
| import org.relaxng.datatype.DatatypeLibrary; |
| import org.relaxng.datatype.helpers.DatatypeLibraryLoader; |
| import org.w3c.dom.TypeInfo; |
| import org.w3c.dom.ls.LSResourceResolver; |
| import org.xml.sax.Attributes; |
| import org.xml.sax.ContentHandler; |
| import org.xml.sax.ErrorHandler; |
| import org.xml.sax.Locator; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.ext.Attributes2Impl; |
| import org.xml.sax.helpers.NamespaceSupport; |
| import gnu.xml.validation.datatype.SimpleType; |
| import gnu.xml.validation.datatype.Type; |
| |
| /** |
| * Streaming validator. |
| * |
| * @author <a href='mailto:dog@gnu.org'>Chris Burdess</a> |
| */ |
| final class XMLSchemaValidatorHandler |
| extends ValidatorHandler |
| { |
| |
| final XMLSchema schema; |
| final TypeInfoProvider typeInfoProvider; |
| final NamespaceSupport namespaceSupport; |
| final DatatypeLibrary typeLibrary; |
| Locator loc; |
| ContentHandler contentHandler; |
| ErrorHandler errorHandler; |
| LSResourceResolver resourceResolver; |
| final LinkedList context; // element context |
| final ArrayList attributes; // attribute context; |
| |
| XMLSchemaValidatorHandler(XMLSchema schema) |
| { |
| this.schema = schema; |
| typeInfoProvider = new XMLSchemaTypeInfoProvider(this); |
| namespaceSupport = new NamespaceSupport(); |
| context = new LinkedList(); |
| attributes = new ArrayList(); |
| final String ns = XMLConstants.W3C_XML_SCHEMA_NS_URI; |
| typeLibrary = new DatatypeLibraryLoader().createDatatypeLibrary(ns); |
| } |
| |
| public ContentHandler getContentHandler() |
| { |
| return contentHandler; |
| } |
| |
| public void setContentHandler(ContentHandler contentHandler) |
| { |
| this.contentHandler = contentHandler; |
| } |
| |
| public ErrorHandler getErrorHandler() |
| { |
| return errorHandler; |
| } |
| |
| public void setErrorHandler(ErrorHandler errorHandler) |
| { |
| this.errorHandler = errorHandler; |
| } |
| |
| public LSResourceResolver getResourceResolver() |
| { |
| return resourceResolver; |
| } |
| |
| public void setResourceResolver(LSResourceResolver resourceResolver) |
| { |
| this.resourceResolver = resourceResolver; |
| } |
| |
| public TypeInfoProvider getTypeInfoProvider() |
| { |
| return typeInfoProvider; |
| } |
| |
| TypeInfo getElementTypeInfo() |
| { |
| return (XMLSchemaElementTypeInfo) context.getFirst(); |
| } |
| |
| TypeInfo getAttributeTypeInfo(int index) |
| { |
| return (XMLSchemaAttributeTypeInfo) attributes.get(index); |
| } |
| |
| boolean isIdAttribute(int index) |
| { |
| XMLSchemaAttributeTypeInfo typeInfo = |
| (XMLSchemaAttributeTypeInfo) attributes.get(index); |
| return typeInfo.id; |
| } |
| |
| boolean isSpecified(int index) |
| { |
| XMLSchemaAttributeTypeInfo typeInfo = |
| (XMLSchemaAttributeTypeInfo) attributes.get(index); |
| return typeInfo.specified; |
| } |
| |
| public void setDocumentLocator(Locator locator) |
| { |
| loc = locator; |
| if (contentHandler != null) |
| { |
| contentHandler.setDocumentLocator(locator); |
| } |
| } |
| |
| public void startDocument() |
| throws SAXException |
| { |
| namespaceSupport.reset(); |
| context.clear(); |
| attributes.clear(); |
| if (contentHandler != null) |
| { |
| contentHandler.startDocument(); |
| } |
| } |
| |
| public void endDocument() |
| throws SAXException |
| { |
| if (contentHandler != null) |
| { |
| contentHandler.endDocument(); |
| } |
| } |
| |
| public void startPrefixMapping(String prefix, String uri) |
| throws SAXException |
| { |
| namespaceSupport.declarePrefix(prefix, uri); |
| if (contentHandler != null) |
| { |
| contentHandler.startPrefixMapping(prefix, uri); |
| } |
| } |
| |
| public void endPrefixMapping(String prefix) |
| throws SAXException |
| { |
| if (contentHandler != null) |
| { |
| contentHandler.endPrefixMapping(prefix); |
| } |
| } |
| |
| public void startElement(String uri, String localName, String qName, |
| Attributes atts) |
| throws SAXException |
| { |
| namespaceSupport.pushContext(); |
| QName name = new QName(uri, localName); |
| ElementDeclaration decl = |
| (ElementDeclaration) schema.elementDeclarations.get(name); |
| // Validation Rule: Element Locally Valid (Element) |
| String xsiType = |
| atts.getValue(XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI, "type"); |
| xsiType = xsiType.trim(); // normalise |
| String xsiNil = |
| atts.getValue(XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI, "nil"); |
| Type type = decl.datatype; |
| if (xsiType.length() > 0) |
| { |
| try |
| { |
| Type specifiedType = resolveType(xsiType); |
| // TODO 4.3 |
| type = specifiedType; |
| } |
| catch (DatatypeException e) // 4.1, 4.2 |
| { |
| ValidationException e2 = |
| new ValidationException("Can't resolve type " + xsiType, |
| loc); |
| e2.initCause(e); |
| throw e2; |
| } |
| } |
| XMLSchemaElementTypeInfo typeInfo = |
| new XMLSchemaElementTypeInfo(schema, decl, type); |
| if (decl == null) // 1 |
| { |
| throw new ValidationException("No declaration for " + name, loc); |
| } |
| if (decl.isAbstract) // 2 |
| { |
| throw new ValidationException("Declaration for " + name + |
| " is abstract", loc); |
| } |
| if (xsiNil.length() > 0) |
| { |
| if (!decl.nillable) // 3.1 |
| { |
| throw new ValidationException("Declaration for " + name + |
| " is nillable but xsi:nil present", |
| loc); |
| } |
| else if ("true".equals(xsiNil)) // 3.2 |
| { |
| typeInfo.nil = true; |
| if (decl.type == XMLSchema.CONSTRAINT_FIXED) // 3.2.2 |
| { |
| throw new ValidationException("Declaration for " + name + |
| " is fixed but xsi:nil is true", |
| loc); |
| } |
| } |
| } |
| // TODO 5, 6, 7 |
| |
| // parent |
| if (!context.isEmpty()) |
| { |
| XMLSchemaElementTypeInfo parent = |
| (XMLSchemaElementTypeInfo) context.getFirst(); |
| if (parent.nil) // Element Locally Valid (Element) 3.2.1 |
| { |
| throw new ValidationException("Parent of " + qName + |
| " is declared xsi:nil", loc); |
| } |
| // TODO |
| } |
| context.addFirst(typeInfo); |
| // attributes |
| int len = atts.getLength(); |
| Attributes2Impl atts2 = new Attributes2Impl(); |
| int count = 0; |
| for (int i = 0; i < len; i++) |
| { |
| String attUri = atts.getURI(i); |
| String attLocalName = atts.getLocalName(i); |
| String attQName = atts.getQName(i); |
| String attValue = atts.getValue(i); |
| |
| if (XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI.equals(attUri)) |
| { |
| continue; // ? |
| } |
| |
| QName attName = new QName(attUri, attLocalName); |
| AttributeDeclaration attDecl = |
| (AttributeDeclaration) schema.attributeDeclarations.get(attName); |
| boolean declared = (attDecl != null); |
| |
| String attType = (attDecl != null) ? |
| attDecl.datatype.toString() : "CDATA"; |
| XMLSchemaAttributeTypeInfo attTypeInfo = |
| new XMLSchemaAttributeTypeInfo(schema, attDecl, true); |
| attributes.add(attTypeInfo); |
| |
| atts2.addAttribute(attUri, attLocalName, attQName, attType, attValue); |
| atts2.setDeclared(count, declared); |
| atts2.setSpecified(count, true); |
| count++; |
| } |
| // add defaulted attributes to atts2 |
| // TODO |
| // atts2.setSpecified(count, false); |
| if (contentHandler != null) |
| { |
| contentHandler.startElement(uri, localName, qName, atts2); |
| } |
| } |
| |
| public void endElement(String uri, String localName, String qName) |
| throws SAXException |
| { |
| // TODO check all required have been seen |
| context.removeFirst(); |
| attributes.clear(); |
| namespaceSupport.popContext(); |
| if (contentHandler != null) |
| { |
| contentHandler.endElement(uri, localName, qName); |
| } |
| } |
| |
| public void characters(char[] ch, int start, int length) |
| throws SAXException |
| { |
| XMLSchemaElementTypeInfo parent = |
| (XMLSchemaElementTypeInfo) context.getFirst(); |
| if (parent.nil) // Element Locally Valid (Element) 3.2.1 |
| { |
| throw new ValidationException(parent.decl.name.toString() + |
| " is declared xsi:nil", |
| loc); |
| } |
| // TODO |
| if (contentHandler != null) |
| { |
| contentHandler.characters(ch, start, length); |
| } |
| } |
| |
| public void ignorableWhitespace(char[] ch, int start, int length) |
| throws SAXException |
| { |
| if (contentHandler != null) |
| { |
| contentHandler.ignorableWhitespace(ch, start, length); |
| } |
| } |
| |
| public void processingInstruction(String target, String data) |
| throws SAXException |
| { |
| if (contentHandler != null) |
| { |
| contentHandler.processingInstruction(target, data); |
| } |
| } |
| |
| public void skippedEntity(String name) |
| throws SAXException |
| { |
| if (contentHandler != null) |
| { |
| contentHandler.skippedEntity(name); |
| } |
| } |
| |
| Type resolveType(String value) |
| throws DatatypeException |
| { |
| QName name = QName.valueOf(value); |
| String prefix = name.getPrefix(); |
| String localName = name.getLocalPart(); |
| if (prefix != null && prefix.length() > 0) |
| { |
| String uri = namespaceSupport.getURI(prefix); |
| if (!XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(uri)) |
| return null; |
| } |
| if ("anyType".equals(localName)) |
| return Type.ANY_TYPE; |
| return (SimpleType) typeLibrary.createDatatype(localName); |
| } |
| |
| } |
| |
