# DOMEventConsumer.java

    /*
     * Copyright 2011, 2012 Odysseus Software GmbH
     *
     * 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.
     */
    package org.apache.synapse.commons.staxon.core.util;

    import java.util.Iterator;

    import javax.xml.XMLConstants;
    import javax.xml.namespace.QName;
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.stream.XMLEventReader;
    import javax.xml.stream.XMLStreamConstants;
    import javax.xml.stream.XMLStreamException;
    import javax.xml.stream.events.Attribute;
    import javax.xml.stream.events.Comment;
    import javax.xml.stream.events.EntityReference;
    import javax.xml.stream.events.Namespace;
    import javax.xml.stream.events.ProcessingInstruction;
    import javax.xml.stream.events.StartElement;
    import javax.xml.stream.events.XMLEvent;
    import javax.xml.stream.util.XMLEventConsumer;

    import org.w3c.dom.Document;
    import org.w3c.dom.Element;
    import org.w3c.dom.Node;

    /**
     * DOM event consumer.
     */
    public class DOMEventConsumer implements XMLEventConsumer {
        private final Document document;
        private final boolean namespaceAware;

        private Node node;

        /**
         * Create namespace-aware consumer instance.
         *
         * @param node the node to which events will be appended
         */
        public DOMEventConsumer(Node node) {
            this(node, true);
        }

        /**
         * Create consumer instance.
         *
         * @param node           the node to which events will be appended
         * @param namespaceAware whether the DOM will be namespace-aware
         */
        public DOMEventConsumer(Node node, boolean namespaceAware) {
            this.document = node.getNodeType() == Node.DOCUMENT_NODE ? (Document) node : node.getOwnerDocument();
            this.namespaceAware = namespaceAware;
            this.node = node;
        }

        private String qName(QName name) {
            if (XMLConstants.DEFAULT_NS_PREFIX.equals(name.getPrefix())) {
                return name.getLocalPart();
            } else {
                return name.getPrefix() + ':' + name.getLocalPart();
            }
        }

        @Override
        public void add(XMLEvent event) throws XMLStreamException {
            switch (event.getEventType()) {
                case XMLStreamConstants.CDATA:
                    node.appendChild(document.createCDATASection(event.asCharacters().getData()));
                    break;
                case XMLStreamConstants.CHARACTERS:
                    node.appendChild(document.createTextNode(event.asCharacters().getData()));
                    break;
                case XMLStreamConstants.COMMENT:
                    node.appendChild(document.createComment(((Comment) event).getText()));
                    break;
                case XMLStreamConstants.END_ELEMENT:
                    node = node.getParentNode();
                    break;
                case XMLStreamConstants.ENTITY_REFERENCE:
                    node.appendChild(document.createEntityReference(((EntityReference) event).getName()));
                    break;
                case XMLStreamConstants.PROCESSING_INSTRUCTION:
                    ProcessingInstruction pi = (ProcessingInstruction) event;
                    node.appendChild(document.createProcessingInstruction(pi.getTarget(), pi.getData()));
                    break;
                case XMLStreamConstants.START_ELEMENT:
                    StartElement startElement = event.asStartElement();
                    QName elementName = startElement.getName();
                    Element element;
                    if (namespaceAware) {
                        element = document.createElementNS(elementName.getNamespaceURI(), qName(elementName));
                    } else {
                        element = document.createElement(elementName.getLocalPart());
                    }
                    Iterator<?> namespaces = startElement.getNamespaces();
                    while (namespaces.hasNext()) {
                        Namespace ns = (Namespace) namespaces.next();
                        element.setAttributeNS(ns.getName().getNamespaceURI(), qName(ns.getName()), ns.getNamespaceURI());
                    }
                    Iterator<?> attributes = startElement.getAttributes();
                    while (attributes.hasNext()) {
                        Attribute at = (Attribute) attributes.next();
                        if (namespaceAware) {
                            element.setAttributeNS(at.getName().getNamespaceURI(), qName(at.getName()), at.getValue());
                        } else {
                            element.setAttribute(at.getName().getLocalPart(), at.getValue());
                        }
                    }
                    node = node.appendChild(element);
                    break;
                case XMLStreamConstants.SPACE:
                case XMLStreamConstants.ENTITY_DECLARATION:
                case XMLStreamConstants.NOTATION_DECLARATION:
                case XMLStreamConstants.START_DOCUMENT:
                case XMLStreamConstants.END_DOCUMENT:
                case XMLStreamConstants.DTD:
                    break;
                default:
                    throw new XMLStreamException("Unexpected event type " + event.getEventType() + "; " + event);
            }
        }

        /**
         * Add all events from the given reader.
         *
         * @param reader
         * @throws XMLStreamException
         */
        public void add(XMLEventReader reader) throws XMLStreamException {
            while (reader.hasNext()) {
                add(reader.nextEvent());
            }
        }

        /**
         * This method will create and populate a {@link org.w3c.dom.Document} from
         * the given event reader.
         *
         * @param reader event reader
         * @return document
         * @throws XMLStreamException
         */
        public static Document consume(XMLEventReader reader) throws XMLStreamException {
            DocumentBuilder documentBuilder;
            try {
                DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
                documentBuilderFactory.setNamespaceAware(true);
                documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
            } catch (ParserConfigurationException e) {
                throw new XMLStreamException(e);
            }
            return consume(reader, documentBuilder);
        }

        /**
         * This method will create and populate a {@link org.w3c.dom.Document} from
         * the given event reader.
         *
         * @param reader          event reader
         * @param documentBuilder
         * @return document
         * @throws XMLStreamException
         */
        public static Document consume(XMLEventReader reader, DocumentBuilder documentBuilder) throws XMLStreamException {
            Document document = documentBuilder.newDocument();
            consume(reader, document);
            return document;
        }

        /**
         * This method will populate given {@link org.w3c.dom.Node} from the given
         * event reader.
         *
         * @param reader event reader
         * @param node   parent node
         * @throws XMLStreamException
         */
        public static void consume(XMLEventReader reader, Node node) throws XMLStreamException {
            boolean namespaceAware = true; // Boolean.FALSE.equals(reader.getProperty(XMLInputFactory.IS_NAMESPACE_AWARE));
            new DOMEventConsumer(node, namespaceAware).add(reader);
        }
    }