Skip to contentPackage: SaajStaxWriterEx$1$1
SaajStaxWriterEx$1$1
Coverage
1: /*
2: * Copyright (c) 2013, 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 com.sun.xml.messaging.saaj.util.stax;
12:
13: import java.io.OutputStream;
14: import java.util.Arrays;
15: import java.util.Iterator;
16: import java.util.UUID;
17:
18: import jakarta.activation.DataHandler;
19: import jakarta.xml.bind.attachment.AttachmentMarshaller;
20: import jakarta.xml.soap.SOAPException;
21: import jakarta.xml.soap.SOAPMessage;
22: import javax.xml.stream.XMLStreamException;
23:
24: import org.jvnet.staxex.Base64Data;
25: import org.jvnet.staxex.BinaryText;
26: import org.jvnet.staxex.MtomEnabled;
27: import org.jvnet.staxex.NamespaceContextEx;
28: import org.jvnet.staxex.StreamingDataHandler;
29: import org.jvnet.staxex.XMLStreamWriterEx;
30: import org.jvnet.staxex.util.MtomStreamWriter;
31: //
32: //import com.sun.xml.ws.api.message.saaj.SaajStaxWriter;
33: //import com.sun.xml.ws.developer.StreamingDataHandler;
34: //import com.sun.xml.ws.streaming.MtomStreamWriter;
35:
36: /**
37: * SaajStaxWriterEx converts XMLStreamWriterEx calls to build an orasaaj SOAPMessage with BinaryTextImpl.
38: *
39: * @author shih-chang.chen@oracle.com
40: */
41: public class SaajStaxWriterEx extends SaajStaxWriter implements XMLStreamWriterEx, MtomStreamWriter {
42:
43: static final protected String xopNS = "http://www.w3.org/2004/08/xop/include";
44: static final protected String Include = "Include";
45: static final protected String href = "href";
46:
47: private enum State {xopInclude, others};
48: private State state = State.others;
49: private BinaryText binaryText;
50:
51: public SaajStaxWriterEx(SOAPMessage msg, String uri) throws SOAPException {
52: super(msg, uri);
53: }
54:
55: @Override
56: public void writeStartElement(String prefix, String ln, String ns) throws XMLStreamException {
57: if (xopNS.equals(ns) && Include.equals(ln)) {
58: state = State.xopInclude;
59: } else {
60: super.writeStartElement(prefix, ln, ns);
61: }
62: }
63:
64: @Override
65: public void writeEndElement() throws XMLStreamException {
66: if (state.equals(State.xopInclude)) {
67: state = State.others;
68: } else {
69: super.writeEndElement();
70: }
71: }
72:
73: @Override
74: public void writeAttribute(String prefix, String ns, String ln, String value) throws XMLStreamException {
75: if (binaryText != null && href.equals(ln)) {
76: return;
77: } else {
78: super.writeAttribute(prefix, ns, ln, value);
79: }
80: }
81:
82: // @Override
83: // public void writeComment(String data) throws XMLStreamException {
84: // ((ElementImpl)currentElement).addCommentNode(data);
85: // }
86: //
87: // @Override
88: // public void writeCData(String data) throws XMLStreamException {
89: // CDataTextImpl cdt = new CDataTextImpl(soap.getSOAPPart(), data);
90: // currentElement.appendChild(cdt);
91: // }
92:
93: @Override
94: public NamespaceContextEx getNamespaceContext() {
95: return new NamespaceContextEx() {
96: @Override
97: public String getNamespaceURI(String prefix) {
98: return currentElement.getNamespaceURI(prefix);
99: }
100: @Override
101: public String getPrefix(String namespaceURI) {
102: return currentElement.lookupPrefix(namespaceURI);
103: }
104: @Override
105: public Iterator<String> getPrefixes(final String namespaceURI) {
106: return new Iterator<String>() {
107: String prefix = getPrefix(namespaceURI);
108: @Override
109: public boolean hasNext() {
110:• return (prefix != null);
111: }
112: @Override
113: public String next() {
114:• if (prefix == null) throw new java.util.NoSuchElementException();
115: String next = prefix;
116: prefix = null;
117: return next;
118: }
119: @Override
120: public void remove() {}
121: };
122: }
123: @Override
124: public Iterator<Binding> iterator() {
125: return new Iterator<Binding>() {
126: @Override
127: public boolean hasNext() { return false; }
128: @Override
129: public Binding next() { return null; }
130: @Override
131: public void remove() {}
132: };
133: }
134: };
135: }
136:
137: @Override
138: public void writeBinary(DataHandler data) throws XMLStreamException {
139: // binaryText = BinaryTextImpl.createBinaryTextFromDataHandler((MessageImpl)soap, null, currentElement.getOwnerDocument(), data);
140: // currentElement.appendChild(binaryText);
141: addBinaryText(data);
142: }
143:
144: @Override
145: public OutputStream writeBinary(String arg0) throws XMLStreamException {
146: return null;
147: }
148:
149: @Override
150: public void writeBinary(byte[] data, int offset, int length, String contentType) throws XMLStreamException {
151: // if (mtomThreshold == -1 || mtomThreshold > length) return null;
152: byte[] bytes = (offset == 0 && length == data.length) ? data : Arrays.copyOfRange(data, offset, offset + length);
153: if (currentElement instanceof MtomEnabled) {
154: binaryText = ((MtomEnabled) currentElement).addBinaryText(bytes);
155: } else {
156: throw new IllegalStateException("The currentElement is not MtomEnabled " + currentElement);
157: }
158: }
159:
160: @Override
161: public void writePCDATA(CharSequence arg0) throws XMLStreamException {
162: if (arg0 instanceof Base64Data) {
163: // The fix of StreamReaderBufferCreator preserves this dataHandler
164: addBinaryText(((Base64Data) arg0).getDataHandler());
165: } else {
166: // We should not normally get here as we expect a DataHandler,
167: // but this is the most general solution. If we do get
168: // something other than a Data Handler, create a Text node with
169: // the data. Another alternative would be to throw an exception,
170: // but in the most general case, we don't know whether this input
171: // is expected.
172: try {
173: currentElement.addTextNode(arg0.toString());
174: } catch (SOAPException e) {
175: throw new XMLStreamException("Cannot add Text node", e);
176: }
177: }
178: }
179:
180: static private String encodeCid() {
181: String cid = "example.jaxws.sun.com";
182: String name = UUID.randomUUID() + "@";
183: return name + cid;
184: }
185:
186: private String addBinaryText(DataHandler data) {
187: String hrefOrCid = null;
188: if (data instanceof StreamingDataHandler) {
189: hrefOrCid = ((StreamingDataHandler) data).getHrefCid();
190: }
191: if (hrefOrCid == null) hrefOrCid = encodeCid();
192:
193: String prefixedCid = (hrefOrCid.startsWith("cid:")) ? hrefOrCid : "cid:" + hrefOrCid;
194: // Should we do the threshold processing on DataHandler ? But that would be
195: // expensive as DataHolder need to read the data again from its source
196: //binaryText = BinaryTextImpl.createBinaryTextFromDataHandler((MessageImpl) soap, prefixedCid, currentElement.getOwnerDocument(), data);
197: //currentElement.appendChild(binaryText);
198: if (currentElement instanceof MtomEnabled) {
199: binaryText = ((MtomEnabled) currentElement).addBinaryText(prefixedCid, data);
200: } else {
201: throw new IllegalStateException("The currentElement is not MtomEnabled " + currentElement);
202: }
203: return hrefOrCid;
204: }
205:
206: @Override
207: public AttachmentMarshaller getAttachmentMarshaller() {
208: return new AttachmentMarshaller() {
209: @Override
210: public String addMtomAttachment(DataHandler data, String ns, String ln) {
211: // if (mtomThreshold == -1) return null;
212: String hrefOrCid = addBinaryText(data);
213: // return binaryText.getHref();
214: return hrefOrCid;
215: }
216:
217: @Override
218: public String addMtomAttachment(byte[] data, int offset, int length, String mimeType, String ns, String ln) {
219: // if (mtomThreshold == -1 || mtomThreshold > length) return null;
220: byte[] bytes = (offset == 0 && length == data.length) ? data : Arrays.copyOfRange(data, offset, offset + length);
221: // binaryText = (BinaryTextImpl) ((ElementImpl) currentElement).addAsBase64TextNode(bytes);
222: if (currentElement instanceof MtomEnabled) {
223: binaryText = ((MtomEnabled) currentElement).addBinaryText(bytes);
224: } else {
225: throw new IllegalStateException("The currentElement is not MtomEnabled " + currentElement);
226: }
227: return binaryText.getHref();
228: }
229:
230: @Override
231: public String addSwaRefAttachment(DataHandler data) {
232: return "cid:"+encodeCid();
233: }
234:
235: @Override
236: public boolean isXOPPackage() {
237: return true;
238: }
239: };
240: }
241: }
![[Jenkins]](/metro/static/513a6969/images/svgs/logo.svg){kind=logo}
