| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| /* CVS Header |
| $Id$ |
| $Log$ |
| */ |
| |
| package org.apache.axis2.xmlbeans; |
| |
| import org.w3c.dom.Document; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.xml.sax.ErrorHandler; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.SAXParseException; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.parsers.ParserConfigurationException; |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.HashMap; |
| |
| public class XSDConfig { |
| private static final String XMLBEANS_NS = "http://xml.apache.org/xmlbeans/2004/02/xbean/config"; |
| private static final String XMLBEANS_QNAME_NODE = "qname"; |
| private static final String XMLBEANS_NS_NODE = "namespace"; |
| |
| /** The parsed xsdconfig file */ |
| private Document xsdConfigDoc = null; |
| /** The list of prefixes on the document root */ |
| private HashMap prefixesToURIMappings = null; |
| /** The list of schema tyes to Java class names */ |
| private HashMap qnamesToJavaNamesMappings = null; |
| /** The list of namespaces to Java package names */ |
| private HashMap nsToJavaPackagesMap = null; |
| /** Indicates whether we have any QName to Java class name mappings */ |
| public boolean hasQNameToJavaNameMappings = false; |
| /** Indicates whether we have any namespace to Java package mappings */ |
| public boolean hasNamespaceToJavaPackageMappings = false; |
| |
| public XSDConfig(String xsdConfigFile) { |
| try { |
| DocumentBuilder builder = null; |
| DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); |
| |
| factory.setNamespaceAware(true); |
| factory.setValidating(false); |
| |
| builder = factory.newDocumentBuilder(); |
| builder.setErrorHandler(new ParseErrorHandler()); |
| |
| xsdConfigDoc = builder.parse(new File(xsdConfigFile)); |
| |
| // Create a mapping for all the namespaces in the document |
| prefixesToURIMappings = new HashMap(); |
| NamedNodeMap attributes = xsdConfigDoc.getDocumentElement().getAttributes(); |
| for (int c = 0; c < attributes.getLength(); c++) { |
| /* Do we have a namespace declaration? |
| * xmlns:mv="urn:weegietech:minerva" |
| */ |
| if (attributes.item(c).getNodeName().indexOf("xmlns:") != -1) { |
| String[] parts = attributes.item(c).getNodeName().split(":"); |
| |
| // Add the prefix to uri mapping to our list |
| prefixesToURIMappings.put(parts[1], attributes.item(c).getNodeValue()); |
| } |
| } |
| |
| // Load up the list of QName to Java class name mappings |
| qnamesToJavaNamesMappings = getQNamesToJavaNames(); |
| if (qnamesToJavaNamesMappings.size() > 0) |
| hasQNameToJavaNameMappings = true; |
| |
| // Load up the list of namespaces to Java packages mappings |
| nsToJavaPackagesMap = getNamespacesToPackages(); |
| if (nsToJavaPackagesMap.size() > 0) |
| hasNamespaceToJavaPackageMappings = true; |
| } catch (IOException ioe) { |
| throw new RuntimeException(ioe); |
| } catch (SAXException se) { |
| throw new RuntimeException(se); |
| } catch (IllegalArgumentException iae) { |
| throw new RuntimeException(iae); |
| } catch (ParserConfigurationException pce) { |
| throw new RuntimeException(pce); |
| } |
| } |
| |
| /** |
| * Returns the pre loaded schema types to Java class names mappings. |
| * |
| * @return HashMap of schema types to Java class names mappings as as specified in the xsdconfig |
| * file. |
| */ |
| public HashMap getSchemaTypesToJavaNames() { |
| return qnamesToJavaNamesMappings; |
| } |
| |
| /** |
| * Returns the pre loaded namespace to Java package mappings. |
| * |
| * @return HashMap of namespace to Java package mappings as as specified in the xsdconfig file. |
| */ |
| public HashMap getNamespacesToJavaPackages() { |
| return nsToJavaPackagesMap; |
| } |
| |
| /** |
| * Loads the schema types to Java class name mappings |
| * |
| * @return HashMap containing the schema types to Java class name mappings as specified in the |
| * xsdconfig file. If there are no mappings, the returned HashMap will be empty. |
| */ |
| private HashMap getQNamesToJavaNames() { |
| HashMap qnamesToJavaNamesMap = new HashMap(); |
| |
| /* Look for all the <xb:qname ... /> nodes as these specify |
| * xml schema types to Java class mappings. |
| * <xb:qname name="mv:moduleType" javaname="Module"/> |
| */ |
| NodeList qnameNodes = xsdConfigDoc.getElementsByTagNameNS(XMLBEANS_NS, XMLBEANS_QNAME_NODE); |
| |
| for (int c = 0; c < qnameNodes.getLength(); c++) { |
| Node qnameNode = qnameNodes.item(c); |
| |
| /* In the xsdconfig file we'll get schema types with a prefix and not a uri. |
| * <xb:qname name="mv:moduleType" javaname="Module"/> |
| * but XMLBeans will call BindingConfig::lookupJavanameForQName with a QName |
| * which has a namespace uri and no prefix. |
| * So we'll store the fully qualifed schema type name in the mapping list. |
| * i.e. we pick it up from the xsdconfig file as: |
| * mv:moduleType |
| * but we'll store it as urn:weegietech:minerva:moduleType |
| */ |
| String schemaType = qnameNode.getAttributes().getNamedItem("name").getNodeValue(); |
| if (schemaType.indexOf(":") != -1) { |
| // mv:moduleType |
| String prefix = schemaType.split(":")[0]; |
| String localName = schemaType.split(":")[1]; |
| |
| if (prefixesToURIMappings.containsKey(prefix)) { |
| // Store as urn:weegietech:minerva:moduleType |
| String key = (String)prefixesToURIMappings.get(prefix) + ":" + localName; |
| |
| // Direct mapping now from schema types to Java class names |
| qnamesToJavaNamesMap.put(key, qnameNode.getAttributes() |
| .getNamedItem("javaname").getNodeValue()); |
| } |
| } |
| } |
| |
| return qnamesToJavaNamesMap; |
| } |
| |
| /** |
| * Loads the namespace to Java package mappings |
| * |
| * @return HashMap containing the namespace to Java package mappings as specified in the |
| * xsdconfig file. If there are no mappings, the returned HashMap will be empty. |
| */ |
| private HashMap getNamespacesToPackages() { |
| HashMap nsToJavaPackagesMap = new HashMap(); |
| |
| /* Look for all the <xb:namespace ... /> nodes as these specify |
| * xml namespace to Java package mappings. |
| * <xb:qname name="mv:moduleType" javaname="Module"/> |
| */ |
| NodeList nsNodes = xsdConfigDoc.getElementsByTagNameNS(XMLBEANS_NS, XMLBEANS_NS_NODE); |
| |
| for (int nsNodesCount = 0; nsNodesCount < nsNodes.getLength(); nsNodesCount++) { |
| Node nsNode = nsNodes.item(nsNodesCount); |
| |
| // What's the current namespace? |
| String uri = nsNode.getAttributes().getNamedItem("uri").getNodeValue(); |
| |
| // Get the package name for the current namespace uri |
| String packageName = null; |
| NodeList childNodes = nsNode.getChildNodes(); |
| for (int childNodesCount = 0; childNodesCount < childNodes.getLength(); |
| childNodesCount++) { |
| Node childNode = childNodes.item(childNodesCount); |
| if (childNode.getLocalName() != null) { |
| if (childNode.getLocalName().equals("package")) { |
| packageName = childNode.getFirstChild().getNodeValue(); |
| } |
| } |
| } |
| |
| // Store the namespace uri to Java package mapping |
| if (packageName != null) { |
| nsToJavaPackagesMap.put(uri, packageName); |
| } |
| } |
| |
| return nsToJavaPackagesMap; |
| } |
| |
| class ParseErrorHandler implements ErrorHandler { |
| public void error(SAXParseException exception) throws SAXException { |
| throw new SAXException(exception); |
| } |
| |
| public void fatalError(SAXParseException exception) throws SAXException { |
| throw new SAXException(exception); |
| } |
| |
| public void warning(SAXParseException exception) throws SAXException { |
| throw new SAXException(exception); |
| } |
| } |
| } |