| /******************************************************************************* |
| * Copyright (c) 2002-2005 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM - Initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.wst.wsi.internal.core.xml.jaxp; |
| |
| |
| import java.io.IOException; |
| import java.util.Enumeration; |
| import java.util.Hashtable; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| |
| import org.apache.xerces.dom.DOMImplementationImpl; |
| import org.apache.xerces.dom.DocumentImpl; |
| import org.apache.xerces.impl.Constants; |
| import org.eclipse.wst.wsi.internal.core.xml.XMLUtils; |
| import org.eclipse.wst.wsi.internal.core.xml.dom.DOMParser; |
| import org.w3c.dom.DOMImplementation; |
| import org.w3c.dom.Document; |
| import org.xml.sax.EntityResolver; |
| import org.xml.sax.ErrorHandler; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.helpers.DefaultHandler; |
| |
| /** |
| * Using this class, we can obtain a Document from XML. This class is a |
| * specialization of javax.xml.parsers.DocumentBuilder. |
| * |
| * An instance of this class can be obtained from the |
| * DocumentBuilderFactory.newDocumentBuilder method. Once an instance |
| * of this class is obtained, XML can be parsed from a variety of input |
| * sources. These input sources are InputStreams, Files, URLs, and SAX |
| * InputSources. |
| |
| This class will javax.xml.parsers.DocumentBuilderFactory... |
| * |
| * @author Peter Brittenham (peterbr@us.ibm.com) |
| * @version 1.0.1 |
| */ |
| public class DocumentBuilderImpl extends DocumentBuilder |
| { |
| protected DOMParser domParser = null; |
| |
| protected EntityResolver entityResolver = null; |
| protected ErrorHandler errorHandler = new DefaultHandler(); |
| |
| protected static final String NAMESPACES_FEATURE = |
| Constants.SAX_FEATURE_PREFIX + Constants.NAMESPACES_FEATURE; |
| protected static final String VALIDATION_FEATURE = |
| Constants.SAX_FEATURE_PREFIX + Constants.VALIDATION_FEATURE; |
| |
| /** |
| * Constructor for DocumentBuilderImpl2. |
| * |
| * @param dbFactory a DocumentBuilderFactory object. |
| * @throws SAXException if any parse errors occur. |
| */ |
| public DocumentBuilderImpl(DocumentBuilderFactory dbFactory, Hashtable attributes) |
| throws SAXException |
| { |
| // Create parser |
| domParser = new DOMParser(); |
| |
| // Set namespace aware |
| domParser.setFeature(NAMESPACES_FEATURE, dbFactory.isNamespaceAware()); |
| |
| // Set validating |
| domParser.setFeature(VALIDATION_FEATURE, dbFactory.isValidating()); |
| if (dbFactory.isValidating()) domParser.setFeature(XMLUtils.FEATURE_VALIDATION_SCHEMA, true); |
| |
| // Do not defer node expansion |
| domParser.setFeature( |
| Constants.XERCES_FEATURE_PREFIX + Constants.DEFER_NODE_EXPANSION_FEATURE, |
| false); |
| |
| // Set other features from the document factory builder |
| domParser.setFeature( |
| Constants.XERCES_FEATURE_PREFIX + Constants.INCLUDE_IGNORABLE_WHITESPACE, |
| !dbFactory.isIgnoringElementContentWhitespace()); |
| domParser.setFeature( |
| Constants.XERCES_FEATURE_PREFIX |
| + Constants.CREATE_ENTITY_REF_NODES_FEATURE, |
| !dbFactory.isExpandEntityReferences()); |
| domParser.setFeature( |
| Constants.XERCES_FEATURE_PREFIX + Constants.INCLUDE_COMMENTS_FEATURE, |
| !dbFactory.isIgnoringComments()); |
| domParser.setFeature( |
| Constants.XERCES_FEATURE_PREFIX + Constants.CREATE_CDATA_NODES_FEATURE, |
| !dbFactory.isCoalescing()); |
| |
| // set features and properties specified at factory level |
| if (attributes != null) |
| { |
| for (Enumeration i=attributes.keys(); i.hasMoreElements();) |
| { |
| String attribute = (String)i.nextElement(); |
| if (attribute.equals(XMLUtils.JAXP_SCHEMA_SOURCE)) |
| { |
| // for multiple schema validation may be array of InputSource |
| if(attributes.get(attribute) instanceof InputSource[]) |
| domParser.setProperty(attribute, (InputSource[])attributes.get(attribute)); |
| else |
| domParser.setProperty(attribute, (InputSource)attributes.get(attribute)); |
| } |
| else |
| { |
| domParser.setProperty(attribute, attributes.get(attribute)); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Parse the content of the given input source as an XML document and return a new DOM. |
| * @param is InputStream containing the content to be parsed. |
| * @throws SAXException if any parse errors occur. |
| * @throws IOException if any IO errors occur. |
| */ |
| public Document parse(InputSource is) throws SAXException, IOException |
| { |
| ClassLoader currentLoader = Thread.currentThread().getContextClassLoader(); |
| try |
| { |
| Thread.currentThread().setContextClassLoader(XMLUtils.class.getClassLoader()); |
| |
| // Set entity resolver |
| if (this.entityResolver != null) |
| domParser.setEntityResolver(this.entityResolver); |
| |
| // Set error handler |
| if (this.errorHandler != null) |
| domParser.setErrorHandler(this.errorHandler); |
| |
| // Parse input source |
| domParser.parse(is); |
| |
| // Return the document that was created |
| return domParser.getDocument(); |
| } |
| finally |
| { |
| Thread.currentThread().setContextClassLoader(currentLoader); |
| } |
| } |
| |
| /** |
| * Indicates whether or not this parser is configured to understand namespaces. |
| * @return true if this parser is configured to understand namespaces; false otherwise. |
| */ |
| public boolean isNamespaceAware() |
| { |
| boolean namespaceAware = false; |
| |
| try |
| { |
| namespaceAware = domParser.getFeature(NAMESPACES_FEATURE); |
| } |
| |
| catch (SAXException se) |
| { |
| throw new RuntimeException(se.toString()); |
| } |
| |
| return namespaceAware; |
| } |
| |
| /** |
| * Indicates whether or not this parser is configured to validate XML documents. |
| * @return true if this parser is configured to validate XML documents; false otherwise. |
| */ |
| public boolean isValidating() |
| { |
| boolean validating = false; |
| |
| try |
| { |
| validating = domParser.getFeature(VALIDATION_FEATURE); |
| } |
| |
| catch (SAXException se) |
| { |
| throw new RuntimeException(se.toString()); |
| } |
| |
| return validating; |
| } |
| |
| /** |
| * Specify the EntityResolver to be used to resolve entities present |
| * in the XML document to be parsed. Setting this to null will result |
| * in the underlying implementation using it's own default |
| * implementation and behavior. |
| * |
| * @param er the EntityResolver to be used to resolve entities |
| * present in the XML document to be parsed. |
| */ |
| public void setEntityResolver(EntityResolver entityResolver) |
| { |
| this.entityResolver = entityResolver; |
| } |
| |
| /** |
| * Specify the ErrorHandler to be used to report errors present in |
| * the XML document to be parsed. Setting this to null will result |
| * in the underlying implementation using it's own default |
| * implementation and behavior. |
| * |
| * param eh the ErrorHandler to be used to report errors present in |
| * the XML document to be parsed. |
| */ |
| public void setErrorHandler(ErrorHandler errorHandler) |
| { |
| this.errorHandler = errorHandler; |
| } |
| |
| /** |
| * Obtain a new instance of a DOM Document object to build a DOM |
| * tree with. An alternative way to create a DOM Document object |
| * is to use the getDOMImplementation method to get a DOM Level 2 |
| * DOMImplementation object and then use DOM Level 2 methods on |
| * that object to create a DOM Document object. |
| * |
| * @return a new instance of a DOM Document object. |
| */ |
| public Document newDocument() |
| { |
| return new DocumentImpl(); |
| } |
| |
| /** |
| * Obtain an instance of a DOMImplementation object. |
| * @return a new instance of a DOMImplementation. |
| */ |
| public DOMImplementation getDOMImplementation() |
| { |
| return new DOMImplementationImpl(); |
| } |
| |
| } |