FileDocCategorySizeDatePackage
DocumentBuilderImpl.javaAPI DocJava SE 6 API14361Tue Jun 10 00:22:48 BST 2008com.sun.org.apache.xerces.internal.jaxp

DocumentBuilderImpl

public class DocumentBuilderImpl extends DocumentBuilder implements JAXPConstants
author
Rajiv Mordani
author
Edwin Goei
version
$Id: DocumentBuilderImpl.java,v 1.2.6.1 2005/09/05 10:05:40 sunithareddy Exp $

Fields Summary
private static final String
NAMESPACES_FEATURE
Feature identifier: namespaces.
private static final String
INCLUDE_IGNORABLE_WHITESPACE
Feature identifier: include ignorable white space.
private static final String
CREATE_ENTITY_REF_NODES_FEATURE
Feature identifier: create entiry ref nodes feature.
private static final String
INCLUDE_COMMENTS_FEATURE
Feature identifier: include comments feature.
private static final String
CREATE_CDATA_NODES_FEATURE
Feature identifier: create cdata nodes feature.
private static final String
XINCLUDE_FEATURE
Feature identifier: XInclude processing
private static final String
XMLSCHEMA_VALIDATION_FEATURE
feature identifier: XML Schema validation
private static final String
VALIDATION_FEATURE
Feature identifier: validation
private static final String
SECURITY_MANAGER
Property identifier: security manager.
private DOMParser
domParser
private final Schema
grammar
private XMLComponent
fSchemaValidator
private XMLComponentManager
fSchemaValidatorComponentManager
private ValidationManager
fSchemaValidationManager
private final ErrorHandler
fInitErrorHandler
Initial ErrorHandler
private final EntityResolver
fInitEntityResolver
Initial EntityResolver
Constructors Summary
DocumentBuilderImpl(DocumentBuilderFactoryImpl dbf, Hashtable dbfAttrs, Hashtable features)

    
         
           
        this(dbf, dbfAttrs, features, false);
DocumentBuilderImpl(DocumentBuilderFactoryImpl dbf, Hashtable dbfAttrs, Hashtable features, boolean secureProcessing)

        domParser = new DOMParser();

        // If validating, provide a default ErrorHandler that prints
        // validation errors with a warning telling the user to set an
        // ErrorHandler
        if (dbf.isValidating()) {
            fInitErrorHandler = new DefaultValidationErrorHandler();
            setErrorHandler(fInitErrorHandler);
        }
        else {
            fInitErrorHandler = domParser.getErrorHandler();
        }

        domParser.setFeature(VALIDATION_FEATURE, dbf.isValidating());

        // "namespaceAware" == SAX Namespaces feature
        domParser.setFeature(NAMESPACES_FEATURE, dbf.isNamespaceAware());

        // Set various parameters obtained from DocumentBuilderFactory
        domParser.setFeature(INCLUDE_IGNORABLE_WHITESPACE, 
                !dbf.isIgnoringElementContentWhitespace());
        domParser.setFeature(CREATE_ENTITY_REF_NODES_FEATURE,
                !dbf.isExpandEntityReferences());
        domParser.setFeature(INCLUDE_COMMENTS_FEATURE,
                !dbf.isIgnoringComments());
        domParser.setFeature(CREATE_CDATA_NODES_FEATURE,
                !dbf.isCoalescing());
        
        // Avoid setting the XInclude processing feature if the value is false.
        // This will keep the configuration from throwing an exception if it
        // does not support XInclude.
        if (dbf.isXIncludeAware()) {
            domParser.setFeature(XINCLUDE_FEATURE, true);
        }
        
        // If the secure processing feature is on set a security manager.
        if (secureProcessing) {
            domParser.setProperty(SECURITY_MANAGER, new SecurityManager());
        }
        
        this.grammar = dbf.getSchema();
        if (grammar != null) {
            XMLParserConfiguration config = domParser.getXMLParserConfiguration();
            XMLComponent validatorComponent = null;
            /** For Xerces grammars, use built-in schema validator. **/
            if (grammar instanceof XSGrammarPoolContainer) {
                validatorComponent = new XMLSchemaValidator();
                fSchemaValidationManager = new ValidationManager();
                XMLDTDFilter entityHandler = new UnparsedEntityHandler(fSchemaValidationManager);
                config.setDTDHandler(entityHandler);
                entityHandler.setDTDHandler(domParser);
                domParser.setDTDSource(entityHandler);
                fSchemaValidatorComponentManager = new SchemaValidatorConfiguration(config, 
                        (XSGrammarPoolContainer) grammar, fSchemaValidationManager);
            }
            /** For third party grammars, use the JAXP validator component. **/
            else {
                validatorComponent = new JAXPValidatorComponent(grammar.newValidatorHandler());
                fSchemaValidatorComponentManager = config;
            }
            config.addRecognizedFeatures(validatorComponent.getRecognizedFeatures());
            config.addRecognizedProperties(validatorComponent.getRecognizedProperties());
            config.setDocumentHandler((XMLDocumentHandler) validatorComponent);
            ((XMLDocumentSource)validatorComponent).setDocumentHandler(domParser);
            domParser.setDocumentSource((XMLDocumentSource) validatorComponent);
            fSchemaValidator = validatorComponent;
        }

        // Set features
        setFeatures(features);
        
        // Set attributes
        setDocumentBuilderFactoryAttributes(dbfAttrs);
        
        // Initial EntityResolver
        fInitEntityResolver = domParser.getEntityResolver();
Methods Summary
public org.w3c.dom.DOMImplementationgetDOMImplementation()

        return DOMImplementationImpl.getDOMImplementation();
com.sun.org.apache.xerces.internal.parsers.DOMParsergetDOMParser()

        return domParser;
public javax.xml.validation.SchemagetSchema()

        return grammar;
public booleanisNamespaceAware()

        try {
            return domParser.getFeature(NAMESPACES_FEATURE);
        } 
        catch (SAXException x) {
            throw new IllegalStateException(x.getMessage());
        }
public booleanisValidating()

        try {
            return domParser.getFeature(VALIDATION_FEATURE);
        } 
        catch (SAXException x) {
            throw new IllegalStateException(x.getMessage());
        }
public booleanisXIncludeAware()
Gets the XInclude processing mode for this parser

return
the state of XInclude processing mode

        try {
            return domParser.getFeature(XINCLUDE_FEATURE);
        }
        catch (SAXException exc) {
            return false;
        }
public org.w3c.dom.DocumentnewDocument()
Non-preferred: use the getDOMImplementation() method instead of this one to get a DOM Level 2 DOMImplementation object and then use DOM Level 2 methods to create a DOM Document object.

        return new com.sun.org.apache.xerces.internal.dom.DocumentImpl();
public org.w3c.dom.Documentparse(org.xml.sax.InputSource is)

        if (is == null) {
            throw new IllegalArgumentException(
                DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, 
                "jaxp-null-input-source", null));
        }
        if (fSchemaValidator != null) {
            if (fSchemaValidationManager != null) {
                fSchemaValidationManager.reset();
            }
            resetSchemaValidator();
        }
        domParser.parse(is);
        return domParser.getDocument();
public voidreset()

        /** Restore the initial error handler. **/
        if (domParser.getErrorHandler() != fInitErrorHandler) {
            domParser.setErrorHandler(fInitErrorHandler);
        }
        /** Restore the initial entity resolver. **/
        if (domParser.getEntityResolver() != fInitEntityResolver) {
            domParser.setEntityResolver(fInitEntityResolver);
        }
private voidresetSchemaValidator()

        try {
            fSchemaValidator.reset(fSchemaValidatorComponentManager);
        }
        // This should never be thrown from the schema validator.
        catch (XMLConfigurationException e) {
            throw new SAXException(e);
        }
private voidsetDocumentBuilderFactoryAttributes(java.util.Hashtable dbfAttrs)
Set any DocumentBuilderFactory attributes of our underlying DOMParser Note: code does not handle possible conflicts between DOMParser attribute names and JAXP specific attribute names, eg. DocumentBuilderFactory.setValidating()

        if (dbfAttrs == null) {
            // Nothing to do
            return;
        }

        for (Enumeration e = dbfAttrs.keys(); e.hasMoreElements();) {
            String name = (String)e.nextElement();
            Object val = dbfAttrs.get(name);
            if (val instanceof Boolean) {
                // Assume feature
                domParser.setFeature(name, ((Boolean)val).booleanValue());
            } else {
                // Assume property
                if (JAXP_SCHEMA_LANGUAGE.equals(name)) {
                    // JAXP 1.2 support
                    //None of the properties will take effect till the setValidating(true) has been called                                        
                    if ( W3C_XML_SCHEMA.equals(val) ) {
                        if( isValidating() ) {
                            domParser.setFeature(XMLSCHEMA_VALIDATION_FEATURE, true);
                            // this should allow us not to emit DTD errors, as expected by the 
                            // spec when schema validation is enabled
                            domParser.setProperty(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);
                        }
                    }
        		} else if(JAXP_SCHEMA_SOURCE.equals(name)){
               		if( isValidating() ) {
						String value=(String)dbfAttrs.get(JAXP_SCHEMA_LANGUAGE);
						if(value !=null && W3C_XML_SCHEMA.equals(value)){
            				domParser.setProperty(name, val);
						}else{
                            throw new IllegalArgumentException(
                                DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, 
                                "jaxp-order-not-supported",
                                new Object[] {JAXP_SCHEMA_LANGUAGE, JAXP_SCHEMA_SOURCE}));
						}
					}
            	} else {
                    // Let Xerces code handle the property
                    domParser.setProperty(name, val);
				}
			}
		}
public voidsetEntityResolver(org.xml.sax.EntityResolver er)

        domParser.setEntityResolver(er);
public voidsetErrorHandler(org.xml.sax.ErrorHandler eh)

        domParser.setErrorHandler(eh);
private voidsetFeatures(java.util.Hashtable features)

        if (features != null) {
            for (Enumeration e = features.keys(); e.hasMoreElements();) {
                String feature = (String)e.nextElement();
                boolean value = ((Boolean)features.get(feature)).booleanValue();
                domParser.setFeature(feature, value);
            }
        }