Java XML Document Create createDocument(boolean isSecureProcessing)

Description

DOM Level 1 did not have a standard mechanism for creating a new Document object.

License

Apache License

Parameter

Parameter	Description
isSecureProcessing	state of the secure processing feature.

Return

The newly created DOM Document object, with no children, or null if we can't find a DOM implementation that permits creating new empty Documents.

Declaration

public static Document createDocument(boolean isSecureProcessing)

Method Source Code

//package com.java2s;
/*//from   w w w  . j  a va2  s .com
 * Copyright 1999-2004 The Apache Software Foundation.
 *
 * Licensed 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.
 */

import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import com.sun.org.apache.xml.internal.res.XMLErrorResources;
import com.sun.org.apache.xml.internal.res.XMLMessages;

import org.w3c.dom.Document;

public class Main {
    /**
     * DOM Level 1 did not have a standard mechanism for creating a new
     * Document object. This function provides a DOM-implementation-independent
     * abstraction for that for that concept. It's typically used when 
     * outputting a new DOM as the result of an operation.
     * <p>
     * TODO: This isn't directly compatable with DOM Level 2. 
     * The Level 2 createDocument call also creates the root 
     * element, and thus requires that you know what that element will be
     * before creating the Document. We should think about whether we want
     * to change this code, and the callers, so we can use the DOM's own 
     * method. (It's also possible that DOM Level 3 may relax this
     * sequence, but you may give up some intelligence in the DOM by
     * doing so; the intent was that knowing the document type and root
     * element might let the DOM automatically switch to a specialized
     * subclass for particular kinds of documents.)
     *
     * @param isSecureProcessing state of the secure processing feature.
     * @return The newly created DOM Document object, with no children, or
     * null if we can't find a DOM implementation that permits creating
     * new empty Documents.
     */
    public static Document createDocument(boolean isSecureProcessing) {

        try {

            // Use an implementation of the JAVA API for XML Parsing 1.0 to
            // create a DOM Document node to contain the result.
            DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance();

            dfactory.setNamespaceAware(true);
            dfactory.setValidating(true);

            if (isSecureProcessing) {
                try {
                    dfactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
                } catch (ParserConfigurationException pce) {
                }
            }

            DocumentBuilder docBuilder = dfactory.newDocumentBuilder();
            Document outNode = docBuilder.newDocument();

            return outNode;
        } catch (ParserConfigurationException pce) {
            throw new RuntimeException(
                    XMLMessages.createXMLMessage(XMLErrorResources.ER_CREATEDOCUMENT_NOT_SUPPORTED, null)); //"createDocument() not supported in XPathContext!");

            // return null;
        }
    }

    /**
     * DOM Level 1 did not have a standard mechanism for creating a new
     * Document object. This function provides a DOM-implementation-independent
     * abstraction for that for that concept. It's typically used when 
     * outputting a new DOM as the result of an operation.
     *
     * @return The newly created DOM Document object, with no children, or
     * null if we can't find a DOM implementation that permits creating
     * new empty Documents.
     */
    public static Document createDocument() {
        return createDocument(false);
    }
}