1 /*

     2  * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package com.sun.xml.internal.org.jvnet.staxex.util;

    27 

    28 import java.io.IOException;

    29 

    30 import javax.xml.bind.attachment.AttachmentMarshaller;

    31 import javax.xml.stream.XMLStreamConstants;

    32 import javax.xml.stream.XMLStreamException;

    33 import javax.xml.stream.XMLStreamReader;

    34 import javax.xml.stream.XMLStreamWriter;

    35 import javax.xml.XMLConstants;

    36 

    37 import com.sun.xml.internal.org.jvnet.staxex.Base64Data;

    38 import com.sun.xml.internal.org.jvnet.staxex.XMLStreamReaderEx;

    39 import com.sun.xml.internal.org.jvnet.staxex.XMLStreamWriterEx;

    40 

    41 /**

    42  * Reads a sub-tree from {@link XMLStreamReader} and writes to {@link XMLStreamWriter}

    43  * as-is.

    44  *

    45  * <p>

    46  * This class can be sub-classed to implement a simple transformation logic.

    47  *

    48  * @author Kohsuke Kawaguchi

    49  * @author Ryan Shoemaker

    50  */

    51 public class XMLStreamReaderToXMLStreamWriter {

    52 

    53     static public class Breakpoint {

    54         protected XMLStreamReader reader;

    55         protected XMLStreamWriter writer;

    56 

    57         public Breakpoint(XMLStreamReader r, XMLStreamWriter w) { reader = r; writer = w; }

    58 

    59         public XMLStreamReader reader() { return reader; }

    60         public XMLStreamWriter writer() { return writer; }

    61         public boolean proceedBeforeStartElement() { return true; }

    62         public boolean proceedAfterStartElement()  { return true; }

    63     }

    64 

    65     private static final int BUF_SIZE = 4096;

    66 

    67     protected XMLStreamReader in;

    68     protected XMLStreamWriter out;

    69 

    70     private char[] buf;

    71 

    72     boolean optimizeBase64Data = false;

    73 

    74     AttachmentMarshaller mtomAttachmentMarshaller;

    75 

    76     /**

    77      * Reads one subtree and writes it out.

    78      *

    79      * <p>

    80      * The {@link XMLStreamWriter} never receives a start/end document event.

    81      * Those need to be written separately by the caller.

    82      */

    83     public void bridge(XMLStreamReader in, XMLStreamWriter out) throws XMLStreamException {

    84         bridge(in, out, null);

    85     }

    86 

    87     public void bridge(Breakpoint breakPoint) throws XMLStreamException {

    88         bridge(breakPoint.reader(), breakPoint.writer(), breakPoint);

    89     }

    90 

    91     private void bridge(XMLStreamReader in, XMLStreamWriter out, Breakpoint breakPoint) throws XMLStreamException {

    92         assert in!=null && out!=null;

    93         this.in = in;

    94         this.out = out;

    95 

    96         optimizeBase64Data = (in instanceof XMLStreamReaderEx);

    97 

    98         if (out instanceof XMLStreamWriterEx && out instanceof MtomStreamWriter) {

    99             mtomAttachmentMarshaller = ((MtomStreamWriter) out).getAttachmentMarshaller();

   100         }

   101         // remembers the nest level of elements to know when we are done.

   102         int depth=0;

   103 

   104         buf = new char[BUF_SIZE];

   105 

   106         // if the parser is at the start tag, proceed to the first element

   107         int event = getEventType();

   108 

   109         if( event!=XMLStreamConstants.START_ELEMENT)

   110             throw new IllegalStateException("The current event is not START_ELEMENT\n but " + event);

   111 

   112         do {

   113             // These are all of the events listed in the javadoc for

   114             // XMLEvent.

   115             // The spec only really describes 11 of them.

   116             switch (event) {

   117                 case XMLStreamConstants.START_ELEMENT :

   118                     if (breakPoint != null && !breakPoint.proceedBeforeStartElement()) return;

   119                     depth++;

   120                     handleStartElement();

   121                     if (breakPoint != null && !breakPoint.proceedAfterStartElement()) return;

   122                     break;

   123                 case XMLStreamConstants.END_ELEMENT :

   124                     handleEndElement();

   125                     depth--;

   126                     if(depth==0)

   127                         return;

   128                     break;

   129                 case XMLStreamConstants.CHARACTERS :

   130                     handleCharacters();

   131                     break;

   132                 case XMLStreamConstants.ENTITY_REFERENCE :

   133                     handleEntityReference();

   134                     break;

   135                 case XMLStreamConstants.PROCESSING_INSTRUCTION :

   136                     handlePI();

   137                     break;

   138                 case XMLStreamConstants.COMMENT :

   139                     handleComment();

   140                     break;

   141                 case XMLStreamConstants.DTD :

   142                     handleDTD();

   143                     break;

   144                 case XMLStreamConstants.CDATA :

   145                     handleCDATA();

   146                     break;

   147                 case XMLStreamConstants.SPACE :

   148                     handleSpace();

   149                     break;

   150                 case XMLStreamConstants.END_DOCUMENT:

   151                     throw new XMLStreamException("Malformed XML at depth="+depth+", Reached EOF. Event="+event);

   152                 default :

   153                     throw new XMLStreamException("Cannot process event: " + event);

   154             }

   155 

   156             event=getNextEvent();

   157         } while (depth!=0);

   158     }

   159 

   160     protected void handlePI() throws XMLStreamException {

   161         out.writeProcessingInstruction(

   162             in.getPITarget(),

   163             in.getPIData());

   164     }

   165 

   166 

   167     protected void handleCharacters() throws XMLStreamException {

   168 

   169         CharSequence c = null;

   170 

   171         if (optimizeBase64Data) {

   172             c = ((XMLStreamReaderEx)in).getPCDATA();

   173         }

   174 

   175         if ((c != null) && (c instanceof Base64Data)) {

   176             if (mtomAttachmentMarshaller != null) {

   177                 Base64Data b64d = (Base64Data) c;

   178                 ((XMLStreamWriterEx)out).writeBinary(b64d.getDataHandler());

   179             } else {

   180                 try {

   181                     ((Base64Data)c).writeTo(out);

   182                 } catch (IOException e) {

   183                     throw new XMLStreamException(e);

   184                 }

   185             }

   186         } else {

   187             for (int start=0,read=buf.length; read == buf.length; start+=buf.length) {

   188                 read = in.getTextCharacters(start, buf, 0, buf.length);

   189                 out.writeCharacters(buf, 0, read);

   190             }

   191         }

   192     }

   193 

   194     protected void handleEndElement() throws XMLStreamException {

   195         out.writeEndElement();

   196     }

   197 

   198     protected void handleStartElement() throws XMLStreamException {

   199         String nsUri = in.getNamespaceURI();

   200         if(nsUri==null)

   201             out.writeStartElement(in.getLocalName());

   202         else

   203             out.writeStartElement(

   204                 fixNull(in.getPrefix()),

   205                 in.getLocalName(),

   206                 nsUri

   207             );

   208 

   209         // start namespace bindings

   210         int nsCount = in.getNamespaceCount();

   211         for (int i = 0; i < nsCount; i++) {

   212             out.writeNamespace(

   213                 in.getNamespacePrefix(i),

   214                 fixNull(in.getNamespaceURI(i)));    // zephyr doesn't like null, I don't know what is correct, so just fix null to "" for now

   215         }

   216 

   217         // write attributes

   218         int attCount = in.getAttributeCount();

   219         for (int i = 0; i < attCount; i++) {

   220             handleAttribute(i);

   221         }

   222     }

   223 

   224     /**

   225      * Writes out the {@code i}-th attribute of the current element.

   226      *

   227      * <p>

   228      * Used from {@link #handleStartElement()}.

   229      */

   230     protected void handleAttribute(int i) throws XMLStreamException {

   231         String nsUri = in.getAttributeNamespace(i);

   232         String prefix = in.getAttributePrefix(i);

   233          if (fixNull(nsUri).equals(XMLConstants.XMLNS_ATTRIBUTE_NS_URI)) {

   234              //Its a namespace decl, ignore as it is already written.

   235              return;

   236          }

   237 

   238         if(nsUri==null || prefix == null || prefix.equals("")) {

   239             out.writeAttribute(

   240                 in.getAttributeLocalName(i),

   241                 in.getAttributeValue(i)

   242             );

   243         } else {

   244             out.writeAttribute(

   245                 prefix,

   246                 nsUri,

   247                 in.getAttributeLocalName(i),

   248                 in.getAttributeValue(i)

   249             );

   250         }

   251     }

   252 

   253     protected void handleDTD() throws XMLStreamException {

   254         out.writeDTD(in.getText());

   255     }

   256 

   257     protected void handleComment() throws XMLStreamException {

   258         out.writeComment(in.getText());

   259     }

   260 

   261     protected void handleEntityReference() throws XMLStreamException {

   262         out.writeEntityRef(in.getText());

   263     }

   264 

   265     protected void handleSpace() throws XMLStreamException {

   266         handleCharacters();

   267     }

   268 

   269     protected void handleCDATA() throws XMLStreamException {

   270         out.writeCData(in.getText());

   271     }

   272 

   273     private static String fixNull(String s) {

   274         if(s==null)     return "";

   275         else            return s;

   276     }

   277 

   278     private int getEventType() throws XMLStreamException {

   279         int event = in.getEventType();

   280      // if the parser is at the start tag, proceed to the first element

   281         //Note - need to do this every time because we could be using a composite reader

   282         if(event == XMLStreamConstants.START_DOCUMENT) {

   283             // nextTag doesn't correctly handle DTDs

   284             while( !in.isStartElement() ) {

   285                 event = in.next();

   286                 if (event == XMLStreamConstants.COMMENT)

   287                     handleComment();

   288             }

   289         }

   290         return event;

   291     }

   292 

   293     private int getNextEvent() throws XMLStreamException {

   294         in.next();

   295         return getEventType();

   296     }

   297 }