FileDocCategorySizeDatePackage
DocumentBuilderFactoryImpl.javaAPI DocApache Xerces 3.0.111142Fri Sep 14 20:33:52 BST 2007org.apache.xerces.jaxp

DocumentBuilderFactoryImpl

public class DocumentBuilderFactoryImpl extends DocumentBuilderFactory
author
Rajiv Mordani
author
Edwin Goei
version
$Id: DocumentBuilderFactoryImpl.java 447237 2006-09-18 05:03:10Z mrglavas $

Fields Summary
private static final String
NAMESPACES_FEATURE
Feature identifier: namespaces.
private static final String
VALIDATION_FEATURE
Feature identifier: validation
private static final String
XINCLUDE_FEATURE
Feature identifier: XInclude processing
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 Hashtable
attributes
These are DocumentBuilderFactory attributes not DOM attributes
private Hashtable
features
private Schema
grammar
private boolean
isXIncludeAware
private boolean
fSecureProcess
State of the secure processing feature, initially false
Constructors Summary
Methods Summary
public java.lang.ObjectgetAttribute(java.lang.String name)
Allows the user to retrieve specific attributes on the underlying implementation.

        // See if it's in the attributes Hashtable
        if (attributes != null) {
            Object val = attributes.get(name);
            if (val != null) {
                return val;
            }
        }

        DOMParser domParser = null;
        try {
            // We create a dummy DocumentBuilderImpl in case the attribute
            // name is not one that is in the attributes hashtable.
            domParser =
                new DocumentBuilderImpl(this, attributes, features).getDOMParser();
            return domParser.getProperty(name);
        } catch (SAXException se1) {
            // assert(name is not recognized or not supported), try feature
            try {
                boolean result = domParser.getFeature(name);
                // Must have been a feature
                return result ? Boolean.TRUE : Boolean.FALSE;
            } catch (SAXException se2) {
                // Not a property or a feature
                throw new IllegalArgumentException(se1.getMessage());
            }
        }
    
public booleangetFeature(java.lang.String name)

        if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
            return fSecureProcess;
        }
        else if (name.equals(NAMESPACES_FEATURE)) {
            return isNamespaceAware();
        }
        else if (name.equals(VALIDATION_FEATURE)) {
            return isValidating();
        }
        else if (name.equals(XINCLUDE_FEATURE)) {
            return isXIncludeAware();
        }
        else if (name.equals(INCLUDE_IGNORABLE_WHITESPACE)) {
            return !isIgnoringElementContentWhitespace();
        }
        else if (name.equals(CREATE_ENTITY_REF_NODES_FEATURE)) {
            return !isExpandEntityReferences();
        }
        else if (name.equals(INCLUDE_COMMENTS_FEATURE)) {
            return !isIgnoringComments();
        }
        else if (name.equals(CREATE_CDATA_NODES_FEATURE)) {
            return !isCoalescing();
        }
        // See if it's in the features Hashtable
        if (features != null) {
            Object val = features.get(name);
            if (val != null) {
                return ((Boolean) val).booleanValue();
            }
        }
        try {
            DOMParser domParser = new DocumentBuilderImpl(this, attributes, features).getDOMParser();
            return domParser.getFeature(name);
        }
        catch (SAXException e) {
            throw new ParserConfigurationException(e.getMessage());
        }
    
public javax.xml.validation.SchemagetSchema()

        return grammar;
    
public booleanisXIncludeAware()

        return this.isXIncludeAware;
    
public javax.xml.parsers.DocumentBuildernewDocumentBuilder()
Creates a new instance of a {@link javax.xml.parsers.DocumentBuilder} using the currently configured parameters.


                      
      
          
    
        /** Check that if a Schema has been specified that neither of the schema properties have been set. */
        if (grammar != null && attributes != null) {
            if (attributes.containsKey(JAXPConstants.JAXP_SCHEMA_LANGUAGE)) {
                throw new ParserConfigurationException(
                        SAXMessageFormatter.formatMessage(null, 
                        "schema-already-specified", new Object[] {JAXPConstants.JAXP_SCHEMA_LANGUAGE}));
            }
            else if (attributes.containsKey(JAXPConstants.JAXP_SCHEMA_SOURCE)) {
                throw new ParserConfigurationException(
                        SAXMessageFormatter.formatMessage(null, 
                        "schema-already-specified", new Object[] {JAXPConstants.JAXP_SCHEMA_SOURCE}));                
            }
        }
        
        try {
            return new DocumentBuilderImpl(this, attributes, features, fSecureProcess);
        } catch (SAXException se) {
            // Handles both SAXNotSupportedException, SAXNotRecognizedException
            throw new ParserConfigurationException(se.getMessage());
        }
    
public voidsetAttribute(java.lang.String name, java.lang.Object value)
Allows the user to set specific attributes on the underlying implementation.

param
name name of attribute
param
value null means to remove attribute

        // This handles removal of attributes
        if (value == null) {
            if (attributes != null) {
                attributes.remove(name);
            }
            // Unrecognized attributes do not cause an exception
            return;
        }
        
        // This is ugly.  We have to collect the attributes and then
        // later create a DocumentBuilderImpl to verify the attributes.

        // Create Hashtable if none existed before
        if (attributes == null) {
            attributes = new Hashtable();
        }

        attributes.put(name, value);

        // Test the attribute name by possibly throwing an exception
        try {
            new DocumentBuilderImpl(this, attributes, features);
        } catch (Exception e) {
            attributes.remove(name);
            throw new IllegalArgumentException(e.getMessage());
        }
    
public voidsetFeature(java.lang.String name, boolean value)

        // If this is the secure processing feature, save it then return.
        if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
            fSecureProcess = value;
            return;
        }
        // Keep built-in settings in synch with the feature values.
        else if (name.equals(NAMESPACES_FEATURE)) {
            setNamespaceAware(value);
            return;
        }
        else if (name.equals(VALIDATION_FEATURE)) {
            setValidating(value);
            return;
        }
        else if (name.equals(XINCLUDE_FEATURE)) {
            setXIncludeAware(value);
            return;
        }
        else if (name.equals(INCLUDE_IGNORABLE_WHITESPACE)) {
            setIgnoringElementContentWhitespace(!value);
            return;
        }
        else if (name.equals(CREATE_ENTITY_REF_NODES_FEATURE)) {
            setExpandEntityReferences(!value);
            return;
        }
        else if (name.equals(INCLUDE_COMMENTS_FEATURE)) {
            setIgnoringComments(!value);
            return;
        }
        else if (name.equals(CREATE_CDATA_NODES_FEATURE)) {
            setCoalescing(!value);
            return;
        }
           
        if (features == null) {
            features = new Hashtable();
        }
        features.put(name, value ? Boolean.TRUE : Boolean.FALSE);
        // Test the feature by possibly throwing SAX exceptions
        try {
            new DocumentBuilderImpl(this, attributes, features);
        } 
        catch (SAXNotSupportedException e) {
            features.remove(name);
            throw new ParserConfigurationException(e.getMessage());
        } 
        catch (SAXNotRecognizedException e) {
            features.remove(name);
            throw new ParserConfigurationException(e.getMessage());
        }
    
public voidsetSchema(javax.xml.validation.Schema grammar)

        this.grammar = grammar;
    
public voidsetXIncludeAware(boolean state)

        this.isXIncludeAware = state;