jaxp/src/share/classes/com/sun/xml/internal/stream/writers/XMLEventWriterImpl.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jaxp/src/share/classes/com/sun/xml/internal/stream/writers/XMLEventWriterImpl.java Sun Mar 04 11:55:34 2012 -0800
@@ -0,0 +1,261 @@
+/*
+ * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.sun.xml.internal.stream.writers;
+
+import java.util.Iterator;
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLEventWriter;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.events.Attribute;
+import javax.xml.stream.events.Characters;
+import javax.xml.stream.events.Comment;
+import javax.xml.stream.events.DTD;
+import javax.xml.stream.events.EntityReference;
+import javax.xml.stream.events.Namespace;
+import javax.xml.stream.events.ProcessingInstruction;
+import javax.xml.stream.events.StartDocument;
+import javax.xml.stream.events.StartElement;
+import javax.xml.stream.events.XMLEvent;
+import javax.xml.stream.XMLStreamWriter;
+
+/**
+ *
+ * @author Neeraj Bajaj, Sun Microsystems.
+ *
+ */
+public class XMLEventWriterImpl implements XMLEventWriter{
+
+ //delegate everything to XMLStreamWriter..
+ private XMLStreamWriter fStreamWriter ;
+ private static final boolean DEBUG = false;
+ /**
+ *
+ * @param streamWriter
+ */
+ public XMLEventWriterImpl(XMLStreamWriter streamWriter){
+ fStreamWriter = streamWriter;
+ }
+
+ /**
+ *
+ * @param xMLEventReader
+ * @throws XMLStreamException
+ */
+ public void add(javax.xml.stream.XMLEventReader xMLEventReader) throws javax.xml.stream.XMLStreamException {
+ if(xMLEventReader == null) throw new XMLStreamException("Event reader shouldn't be null");
+ while(xMLEventReader.hasNext()){
+ add(xMLEventReader.nextEvent());
+ }
+ }
+
+ /**
+ *
+ * @param xMLEvent
+ * @throws XMLStreamException
+ */
+ public void add(javax.xml.stream.events.XMLEvent xMLEvent) throws javax.xml.stream.XMLStreamException {
+ int type = xMLEvent.getEventType();
+ switch(type){
+ case XMLEvent.DTD:{
+ DTD dtd = (DTD)xMLEvent ;
+ if (DEBUG)System.out.println("Adding DTD = " + dtd.toString());
+ fStreamWriter.writeDTD(dtd.getDocumentTypeDeclaration());
+ break;
+ }
+ case XMLEvent.START_DOCUMENT :{
+ StartDocument startDocument = (StartDocument)xMLEvent ;
+ if (DEBUG)System.out.println("Adding StartDocument = " + startDocument.toString());
+ try {
+ fStreamWriter.writeStartDocument(startDocument.getCharacterEncodingScheme(), startDocument.getVersion());
+ }catch(XMLStreamException e) {
+ fStreamWriter.writeStartDocument(startDocument.getVersion());
+ }
+ break;
+ }
+ case XMLEvent.START_ELEMENT :{
+ StartElement startElement = xMLEvent.asStartElement() ;
+ if (DEBUG)System.out.println("Adding startelement = " + startElement.toString());
+ QName qname = startElement.getName();
+ fStreamWriter.writeStartElement(qname.getPrefix(), qname.getLocalPart(), qname.getNamespaceURI());
+
+ //getNamespaces() Returns an Iterator of namespaces declared on this element. This Iterator does not contain
+ //previously declared namespaces unless they appear on the current START_ELEMENT. Therefore
+ //this list may contain redeclared namespaces and duplicate namespace declarations. Use the
+ //getNamespaceContext() method to get the current context of namespace declarations.
+
+ //so we should be using getNamespaces() to write namespace declarations for this START_ELEMENT
+ Iterator iterator = startElement.getNamespaces();
+ while(iterator.hasNext()){
+ Namespace namespace = (Namespace)iterator.next();
+ fStreamWriter.writeNamespace(namespace.getPrefix(), namespace.getNamespaceURI());
+ }
+ //REVISIT: What about writing attributes ?
+ Iterator attributes = startElement.getAttributes();
+ while(attributes.hasNext()){
+ Attribute attribute = (Attribute)attributes.next();
+ QName aqname = attribute.getName();
+ fStreamWriter.writeAttribute(aqname.getPrefix(), aqname.getNamespaceURI(), aqname.getLocalPart(),attribute.getValue());
+ }
+ break;
+ }
+ case XMLEvent.NAMESPACE:{
+ Namespace namespace = (Namespace)xMLEvent;
+ if (DEBUG)System.out.println("Adding namespace = " + namespace.toString());
+ fStreamWriter.writeNamespace(namespace.getPrefix(), namespace.getNamespaceURI());
+ break ;
+ }
+ case XMLEvent.COMMENT: {
+ Comment comment = (Comment)xMLEvent ;
+ if (DEBUG)System.out.println("Adding comment = " + comment.toString());
+ fStreamWriter.writeComment(comment.getText());
+ break;
+ }
+ case XMLEvent.PROCESSING_INSTRUCTION:{
+ ProcessingInstruction processingInstruction = (ProcessingInstruction)xMLEvent ;
+ if (DEBUG)System.out.println("Adding processing instruction = " + processingInstruction.toString());
+ fStreamWriter.writeProcessingInstruction(processingInstruction.getTarget(), processingInstruction.getData());
+ break;
+ }
+ case XMLEvent.CHARACTERS:{
+ Characters characters = xMLEvent.asCharacters();
+ if (DEBUG)System.out.println("Adding characters = " + characters.toString());
+ //check if the CHARACTERS are CDATA
+ if(characters.isCData()){
+ fStreamWriter.writeCData(characters.getData());
+ }
+ else{
+ fStreamWriter.writeCharacters(characters.getData());
+ }
+ break;
+ }
+ case XMLEvent.ENTITY_REFERENCE:{
+ EntityReference entityReference = (EntityReference)xMLEvent ;
+ if (DEBUG)System.out.println("Adding Entity Reference = "+ entityReference.toString());
+ fStreamWriter.writeEntityRef(entityReference.getName());
+ break;
+ }
+ case XMLEvent.ATTRIBUTE:{
+ Attribute attribute = (Attribute)xMLEvent;
+ if (DEBUG)System.out.println("Adding Attribute = " + attribute.toString());
+ QName qname = attribute.getName();
+ fStreamWriter.writeAttribute(qname.getPrefix(), qname.getNamespaceURI(), qname.getLocalPart(),attribute.getValue());
+ break;
+ }
+ case XMLEvent.CDATA:{
+ //there is no separate CDATA datatype but CDATA event can be reported
+ //by using vendor specific CDATA property.
+ Characters characters = (Characters)xMLEvent;
+ if (DEBUG)System.out.println("Adding characters = " + characters.toString());
+ if(characters.isCData()){
+ fStreamWriter.writeCData(characters.getData());
+ }
+ break;
+ }
+ //xxx: Why there isn't any event called Notation.
+ //case XMLEvent.NOTATION_DECLARATION:{
+ //}
+
+ case XMLEvent.END_ELEMENT:{
+ //we dont need to typecast it.. just call writeEndElement() and fStreamWriter will take care of it.
+ //EndElement endElement = (EndElement)xMLEvent;
+ fStreamWriter.writeEndElement();
+ break;
+ }
+ case XMLEvent.END_DOCUMENT:{
+ //we dont need to typecast just call writeEndDocument() and fStreamWriter will take care rest.
+ //EndDocument endDocument = (EndDocument)xMLEvent;
+ fStreamWriter.writeEndDocument();
+ break;
+ }
+ //throw new XMLStreamException("Unknown Event type = " + type);
+ };
+
+ }
+
+ /**
+ *
+ * @throws XMLStreamException
+ */
+ public void close() throws javax.xml.stream.XMLStreamException {
+ fStreamWriter.close();
+ }
+
+ /**
+ *
+ * @throws XMLStreamException will inturn call flush on the stream to which data is being
+ * written.
+ */
+ public void flush() throws javax.xml.stream.XMLStreamException {
+ fStreamWriter.flush();
+ }
+
+ /**
+ *
+ * @return
+ */
+ public javax.xml.namespace.NamespaceContext getNamespaceContext() {
+ return fStreamWriter.getNamespaceContext();
+ }
+
+ /**
+ *
+ * @param namespaceURI Namespace URI
+ * @throws XMLStreamException
+ * @return prefix associated with the URI.
+ */
+ public String getPrefix(String namespaceURI) throws javax.xml.stream.XMLStreamException {
+ return fStreamWriter.getPrefix(namespaceURI);
+ }
+
+ /**
+ *
+ * @param uri Namespace URI
+ * @throws XMLStreamException
+ */
+ public void setDefaultNamespace(String uri) throws javax.xml.stream.XMLStreamException {
+ fStreamWriter.setDefaultNamespace(uri);
+ }
+
+ /**
+ *
+ * @param namespaceContext Namespace Context
+ * @throws XMLStreamException
+ */
+ public void setNamespaceContext(javax.xml.namespace.NamespaceContext namespaceContext) throws javax.xml.stream.XMLStreamException {
+ fStreamWriter.setNamespaceContext(namespaceContext);
+ }
+
+ /**
+ *
+ * @param prefix namespace prefix associated with the uri.
+ * @param uri Namespace URI
+ * @throws XMLStreamException
+ */
+ public void setPrefix(String prefix, String uri) throws javax.xml.stream.XMLStreamException {
+ fStreamWriter.setPrefix(prefix, uri);
+ }
+
+}//XMLEventWriterImpl