![[Jenkins]](/jaxb-impl/static/cdbe4b11/images/svgs/logo.svg){kind=logo}
Package: XMLStreamReaderToXMLStreamWriter$Breakpoint
XMLStreamReaderToXMLStreamWriter$Breakpoint
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| XMLStreamReaderToXMLStreamWriter.Breakpoint(XMLStreamReader, XMLStreamWriter) |
|
|
|
|
|
||||||||||||||||||||
| proceedAfterStartElement() |
|
|
|
|
|
||||||||||||||||||||
| proceedBeforeStartElement() |
|
|
|
|
|
||||||||||||||||||||
| reader() |
|
|
|
|
|
||||||||||||||||||||
| writer() |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*
2: * Copyright (c) 1997, 2022 Oracle and/or its affiliates. All rights reserved.
3: *
4: * This program and the accompanying materials are made available under the
5: * terms of the Eclipse Distribution License v. 1.0, which is available at
6: * http://www.eclipse.org/org/documents/edl-v10.php.
7: *
8: * SPDX-License-Identifier: BSD-3-Clause
9: */
10:
11: package org.jvnet.staxex.util;
12:
13: import java.io.IOException;
14:
15: import jakarta.xml.bind.attachment.AttachmentMarshaller;
16: import javax.xml.stream.XMLStreamConstants;
17: import javax.xml.stream.XMLStreamException;
18: import javax.xml.stream.XMLStreamReader;
19: import javax.xml.stream.XMLStreamWriter;
20: import javax.xml.XMLConstants;
21:
22: import org.jvnet.staxex.Base64Data;
23: import org.jvnet.staxex.XMLStreamReaderEx;
24: import org.jvnet.staxex.XMLStreamWriterEx;
25:
26: /**
27: * Reads a sub-tree from {@link XMLStreamReader} and writes to {@link XMLStreamWriter}
28: * as-is.
29: *
30: * <p>
31: * This class can be sub-classed to implement a simple transformation logic.
32: *
33: * @author Kohsuke Kawaguchi
34: * @author Ryan Shoemaker
35: */
36: public class XMLStreamReaderToXMLStreamWriter {
37:
38: static public class Breakpoint {
39: protected XMLStreamReader reader;
40: protected XMLStreamWriter writer;
41:
42: public Breakpoint(XMLStreamReader r, XMLStreamWriter w) { reader = r; writer = w; }
43:
44: public XMLStreamReader reader() { return reader; }
45: public XMLStreamWriter writer() { return writer; }
46: public boolean proceedBeforeStartElement() { return true; }
47: public boolean proceedAfterStartElement() { return true; }
48: }
49:
50: private static final int BUF_SIZE = 4096;
51:
52: protected XMLStreamReader in;
53: protected XMLStreamWriter out;
54:
55: private char[] buf;
56:
57: boolean optimizeBase64Data = false;
58:
59: AttachmentMarshaller mtomAttachmentMarshaller;
60:
61: public XMLStreamReaderToXMLStreamWriter() {
62: super();
63: }
64:
65: /**
66: * Reads one subtree and writes it out.
67: *
68: * <p>
69: * The {@link XMLStreamWriter} never receives a start/end document event.
70: * Those need to be written separately by the caller.
71: */
72: public void bridge(XMLStreamReader in, XMLStreamWriter out) throws XMLStreamException {
73: bridge(in, out, null);
74: }
75:
76: public void bridge(Breakpoint breakPoint) throws XMLStreamException {
77: bridge(breakPoint.reader(), breakPoint.writer(), breakPoint);
78: }
79:
80: private void bridge(XMLStreamReader in, XMLStreamWriter out, Breakpoint breakPoint) throws XMLStreamException {
81: assert in!=null && out!=null;
82: this.in = in;
83: this.out = out;
84:
85: optimizeBase64Data = (in instanceof XMLStreamReaderEx);
86:
87: if (out instanceof XMLStreamWriterEx && out instanceof MtomStreamWriter) {
88: mtomAttachmentMarshaller = ((MtomStreamWriter) out).getAttachmentMarshaller();
89: }
90: // remembers the nest level of elements to know when we are done.
91: int depth=0;
92:
93: buf = new char[BUF_SIZE];
94:
95: // if the parser is at the start tag, proceed to the first element
96: int event = getEventType();
97:
98: if( event!=XMLStreamConstants.START_ELEMENT)
99: throw new IllegalStateException("The current event is not START_ELEMENT\n but " + event);
100:
101: do {
102: // These are all of the events listed in the javadoc for
103: // XMLEvent.
104: // The spec only really describes 11 of them.
105: switch (event) {
106: case XMLStreamConstants.START_ELEMENT :
107: if (breakPoint != null && !breakPoint.proceedBeforeStartElement()) return;
108: depth++;
109: handleStartElement();
110: if (breakPoint != null && !breakPoint.proceedAfterStartElement()) return;
111: break;
112: case XMLStreamConstants.END_ELEMENT :
113: handleEndElement();
114: depth--;
115: if(depth==0)
116: return;
117: break;
118: case XMLStreamConstants.CHARACTERS :
119: handleCharacters();
120: break;
121: case XMLStreamConstants.ENTITY_REFERENCE :
122: handleEntityReference();
123: break;
124: case XMLStreamConstants.PROCESSING_INSTRUCTION :
125: handlePI();
126: break;
127: case XMLStreamConstants.COMMENT :
128: handleComment();
129: break;
130: case XMLStreamConstants.DTD :
131: handleDTD();
132: break;
133: case XMLStreamConstants.CDATA :
134: handleCDATA();
135: break;
136: case XMLStreamConstants.SPACE :
137: handleSpace();
138: break;
139: case XMLStreamConstants.END_DOCUMENT:
140: throw new XMLStreamException("Malformed XML at depth="+depth+", Reached EOF. Event="+event);
141: default :
142: throw new XMLStreamException("Cannot process event: " + event);
143: }
144:
145: event=getNextEvent();
146: } while (depth!=0);
147: }
148:
149: protected void handlePI() throws XMLStreamException {
150: out.writeProcessingInstruction(
151: in.getPITarget(),
152: in.getPIData());
153: }
154:
155:
156: protected void handleCharacters() throws XMLStreamException {
157:
158: CharSequence c = null;
159:
160: if (optimizeBase64Data) {
161: c = ((XMLStreamReaderEx)in).getPCDATA();
162: }
163:
164: if ((c != null) && (c instanceof Base64Data)) {
165: if (mtomAttachmentMarshaller != null) {
166: Base64Data b64d = (Base64Data) c;
167: ((XMLStreamWriterEx)out).writeBinary(b64d.getDataHandler());
168: } else {
169: try {
170: ((Base64Data)c).writeTo(out);
171: } catch (IOException e) {
172: throw new XMLStreamException(e);
173: }
174: }
175: } else {
176: for (int start=0,read=buf.length; read == buf.length; start+=buf.length) {
177: read = in.getTextCharacters(start, buf, 0, buf.length);
178: out.writeCharacters(buf, 0, read);
179: }
180: }
181: }
182:
183: protected void handleEndElement() throws XMLStreamException {
184: out.writeEndElement();
185: }
186:
187: protected void handleStartElement() throws XMLStreamException {
188: String nsUri = in.getNamespaceURI();
189: if(nsUri==null)
190: out.writeStartElement(in.getLocalName());
191: else
192: out.writeStartElement(
193: fixNull(in.getPrefix()),
194: in.getLocalName(),
195: nsUri
196: );
197:
198: // start namespace bindings
199: int nsCount = in.getNamespaceCount();
200: for (int i = 0; i < nsCount; i++) {
201: out.writeNamespace(
202: fixNull(in.getNamespacePrefix(i)), //StAX reader will return null for default NS
203: fixNull(in.getNamespaceURI(i))); // zephyr doesn't like null, I don't know what is correct, so just fix null to "" for now
204: }
205:
206: // write attributes
207: int attCount = in.getAttributeCount();
208: for (int i = 0; i < attCount; i++) {
209: handleAttribute(i);
210: }
211: }
212:
213: /**
214: * Writes out the {@code i}-th attribute of the current element.
215: *
216: * <p>
217: * Used from {@link #handleStartElement()}.
218: */
219: protected void handleAttribute(int i) throws XMLStreamException {
220: String nsUri = in.getAttributeNamespace(i);
221: String prefix = in.getAttributePrefix(i);
222: if (fixNull(nsUri).equals(XMLConstants.XMLNS_ATTRIBUTE_NS_URI)) {
223: //Its a namespace decl, ignore as it is already written.
224: return;
225: }
226:
227: if(nsUri==null || prefix == null || prefix.equals("")) {
228: out.writeAttribute(
229: in.getAttributeLocalName(i),
230: in.getAttributeValue(i)
231: );
232: } else {
233: out.writeAttribute(
234: prefix,
235: nsUri,
236: in.getAttributeLocalName(i),
237: in.getAttributeValue(i)
238: );
239: }
240: }
241:
242: protected void handleDTD() throws XMLStreamException {
243: out.writeDTD(in.getText());
244: }
245:
246: protected void handleComment() throws XMLStreamException {
247: out.writeComment(in.getText());
248: }
249:
250: protected void handleEntityReference() throws XMLStreamException {
251: out.writeEntityRef(in.getText());
252: }
253:
254: protected void handleSpace() throws XMLStreamException {
255: handleCharacters();
256: }
257:
258: protected void handleCDATA() throws XMLStreamException {
259: out.writeCData(in.getText());
260: }
261:
262: private static String fixNull(String s) {
263: if(s==null) return "";
264: else return s;
265: }
266:
267: private int getEventType() throws XMLStreamException {
268: int event = in.getEventType();
269: // if the parser is at the start tag, proceed to the first element
270: //Note - need to do this every time because we could be using a composite reader
271: if(event == XMLStreamConstants.START_DOCUMENT) {
272: // nextTag doesn't correctly handle DTDs
273: while( !in.isStartElement() ) {
274: event = in.next();
275: if (event == XMLStreamConstants.COMMENT)
276: handleComment();
277: }
278: }
279: return event;
280: }
281:
282: private int getNextEvent() throws XMLStreamException {
283: in.next();
284: return getEventType();
285: }
286: }