1 /*
2 * Copyright (c) 1997, 2017, 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.bind.v2.runtime.output;
27
28 import com.sun.xml.internal.bind.marshaller.NoEscapeHandler;
29 import com.sun.xml.internal.bind.v2.runtime.JAXBContextImpl;
30 import com.sun.xml.internal.bind.v2.runtime.Name;
31 import com.sun.xml.internal.bind.v2.runtime.XMLSerializer;
32 import com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data;
33 import com.sun.xml.internal.fastinfoset.EncodingConstants;
34 import com.sun.xml.internal.fastinfoset.stax.StAXDocumentSerializer;
35 import com.sun.xml.internal.org.jvnet.fastinfoset.VocabularyApplicationData;
36 import org.xml.sax.SAXException;
37
38 import javax.xml.bind.JAXBContext;
39 import javax.xml.stream.XMLStreamException;
40 import java.io.IOException;
41 import java.util.Collection;
42 import java.util.Map;
43 import java.util.WeakHashMap;
44
45 /**
46 * {@link XmlOutput} for {@link StAXDocumentSerializer}.
47 * <p>
48 * This class is responsible for managing the indexing of elements, attributes
49 * and local names that are known to JAXB by way of the JAXBContext (generated
50 * from JAXB beans or schema). The pre-encoded UTF-8 representations of known
51 * local names are also utilized.
52 * <p>
53 * The lookup of elements, attributes and local names with respect to a context
54 * is very efficient. It relies on an incrementing base line so that look up is
55 * performed in O(1) time and only uses static memory. When the base line reaches
56 * a point where integer overflow will occur the arrays and base line are reset
57 * (such an event is rare and will have little impact on performance).
58 * <p>
59 * A weak map of JAXB contexts to optimized tables for attributes, elements and
60 * local names is utilized and stored on the LowLevel StAX serializer. Thus,
61 * optimized serializing can work other multiple serializing of JAXB beans using
62 * the same LowLevel StAX serializer instance. This approach works best when JAXB
63 * contexts are only created once per schema or JAXB beans (which is the recommended
64 * practice as the creation JAXB contexts are expensive, they are thread safe and
65 * can be reused).
66 *
67 * @author Paul.Sandoz@Sun.Com
68 */
69 public final class FastInfosetStreamWriterOutput extends XMLStreamWriterOutput {
70 private final StAXDocumentSerializer fiout;
71 private final Encoded[] localNames;
72 private final TablesPerJAXBContext tables;
73
74 /**
75 * Holder for the optimzed element, attribute and
76 * local name tables.
77 */
78 final static class TablesPerJAXBContext {
79 final int[] elementIndexes;
80 final int[] elementIndexPrefixes;
81
82 final int[] attributeIndexes;
83 final int[] localNameIndexes;
84
85 /**
86 * The offset of the index
87 */
88 int indexOffset;
89
90 /**
91 * The the maximum known value of an index
92 */
93 int maxIndex;
94
95 /**
96 * True if the tables require clearing
97 */
98 boolean requiresClear;
99
100 /**
101 * Create a new set of tables for a JAXB context.
102 * <p>
103 * @param context the JAXB context.
104 * @param initialIndexOffset the initial index offset to calculate
105 * the maximum possible index
106 *
107 */
108 TablesPerJAXBContext(JAXBContextImpl context, int initialIndexOffset) {
109 elementIndexes = new int[context.getNumberOfElementNames()];
110 elementIndexPrefixes = new int[context.getNumberOfElementNames()];
111 attributeIndexes = new int[context.getNumberOfAttributeNames()];
112 localNameIndexes = new int[context.getNumberOfLocalNames()];
113
114 indexOffset = 1;
115 maxIndex = initialIndexOffset + elementIndexes.length + attributeIndexes.length;
116 }
117
118 /**
119 * Require that tables are cleared.
120 */
121 public void requireClearTables() {
122 requiresClear = true;
123 }
124
125 /**
126 * Clear or reset the tables.
127 * <p>
128 * @param intialIndexOffset the initial index offset to calculate
129 * the maximum possible index
130 */
131 public void clearOrResetTables(int intialIndexOffset) {
132 if (requiresClear) {
133 requiresClear = false;
134
135 // Increment offset to new position
136 indexOffset += maxIndex;
137 // Reset the maximum known value of an index
138 maxIndex = intialIndexOffset + elementIndexes.length + attributeIndexes.length;
139 // Check if there is enough free space
140 // If overflow
141 if ((indexOffset + maxIndex) < 0) {
142 clearAll();
143 }
144 } else {
145 // Reset the maximum known value of an index
146 maxIndex = intialIndexOffset + elementIndexes.length + attributeIndexes.length;
147 // Check if there is enough free space
148 // If overflow
149 if ((indexOffset + maxIndex) < 0) {
150 resetAll();
151 }
152 }
153 }
154
155 private void clearAll() {
156 clear(elementIndexes);
157 clear(attributeIndexes);
158 clear(localNameIndexes);
159 indexOffset = 1;
160 }
161
162 private void clear(int[] array) {
163 for (int i = 0; i < array.length; i++) {
164 array[i] = 0;
165 }
166 }
167
168 /**
169 * Increment the maximum know index value
170 * <p>
171 * The indexes are preserved.
172 */
173 public void incrementMaxIndexValue() {
174 // Increment the maximum value of an index
175 maxIndex++;
176 // Check if there is enough free space
177 // If overflow
178 if ((indexOffset + maxIndex) < 0) {
179 resetAll();
180 }
181 }
182
183 private void resetAll() {
184 clear(elementIndexes);
185 clear(attributeIndexes);
186 clear(localNameIndexes);
187 indexOffset = 1;
188 }
189
190 private void reset(int[] array) {
191 for (int i = 0; i < array.length; i++) {
192 if (array[i] > indexOffset) {
193 array[i] = array[i] - indexOffset + 1;
194 } else {
195 array[i] = 0;
196 }
197 }
198 }
199
200 }
201
202 /**
203 * Holder of JAXB contexts -> tables.
204 * <p>
205 * An instance will be registered with the
206 * {@link StAXDocumentSerializer}.
207 */
208 final static class AppData implements VocabularyApplicationData {
209 final Map<JAXBContext, TablesPerJAXBContext> contexts =
210 new WeakHashMap<JAXBContext, TablesPerJAXBContext>();
211 final Collection<TablesPerJAXBContext> collectionOfContexts = contexts.values();
212
213 /**
214 * Clear all the tables.
215 */
216 public void clear() {
217 for(TablesPerJAXBContext c : collectionOfContexts)
218 c.requireClearTables();
219 }
220 }
221
222 public FastInfosetStreamWriterOutput(StAXDocumentSerializer out,
223 JAXBContextImpl context) {
224 super(out, NoEscapeHandler.theInstance);
225
226 this.fiout = out;
227 this.localNames = context.getUTF8NameTable();
228
229 final VocabularyApplicationData vocabAppData = fiout.getVocabularyApplicationData();
230 AppData appData = null;
231 if (vocabAppData == null || !(vocabAppData instanceof AppData)) {
232 appData = new AppData();
233 fiout.setVocabularyApplicationData(appData);
234 } else {
235 appData = (AppData)vocabAppData;
236 }
237
238 final TablesPerJAXBContext tablesPerContext = appData.contexts.get(context);
239 if (tablesPerContext != null) {
240 tables = tablesPerContext;
241 /**
242 * Obtain the current local name index. Thus will be used to
243 * calculate the maximum index value when serializing for this context
244 */
245 tables.clearOrResetTables(out.getLocalNameIndex());
246 } else {
247 tables = new TablesPerJAXBContext(context, out.getLocalNameIndex());
248 appData.contexts.put(context, tables);
249 }
250 }
251
252 @Override
253 public void startDocument(XMLSerializer serializer, boolean fragment,
254 int[] nsUriIndex2prefixIndex, NamespaceContextImpl nsContext)
255 throws IOException, SAXException, XMLStreamException {
256 super.startDocument(serializer, fragment, nsUriIndex2prefixIndex, nsContext);
257
258 if (fragment)
259 fiout.initiateLowLevelWriting();
260 }
261
262 @Override
263 public void endDocument(boolean fragment) throws IOException, SAXException, XMLStreamException {
264 super.endDocument(fragment);
265 }
266
267 @Override
268 public void beginStartTag(Name name) throws IOException {
269 fiout.writeLowLevelTerminationAndMark();
270
271 if (nsContext.getCurrent().count() == 0) {
272 final int qNameIndex = tables.elementIndexes[name.qNameIndex] - tables.indexOffset;
273 final int prefixIndex = nsUriIndex2prefixIndex[name.nsUriIndex];
274
275 if (qNameIndex >= 0 &&
276 tables.elementIndexPrefixes[name.qNameIndex] == prefixIndex) {
277 fiout.writeLowLevelStartElementIndexed(EncodingConstants.ELEMENT, qNameIndex);
278 } else {
279 tables.elementIndexes[name.qNameIndex] = fiout.getNextElementIndex() + tables.indexOffset;
280 tables.elementIndexPrefixes[name.qNameIndex] = prefixIndex;
281 writeLiteral(EncodingConstants.ELEMENT | EncodingConstants.ELEMENT_LITERAL_QNAME_FLAG,
282 name,
283 nsContext.getPrefix(prefixIndex),
284 nsContext.getNamespaceURI(prefixIndex));
285 }
286 } else {
287 beginStartTagWithNamespaces(name);
288 }
289 }
290
291 public void beginStartTagWithNamespaces(Name name) throws IOException {
292 final NamespaceContextImpl.Element nse = nsContext.getCurrent();
293
294 fiout.writeLowLevelStartNamespaces();
295 for (int i = nse.count() - 1; i >= 0; i--) {
296 final String uri = nse.getNsUri(i);
297 if (uri.length() == 0 && nse.getBase() == 1)
298 continue; // no point in definint xmlns='' on the root
299 fiout.writeLowLevelNamespace(nse.getPrefix(i), uri);
300 }
301 fiout.writeLowLevelEndNamespaces();
302
303 final int qNameIndex = tables.elementIndexes[name.qNameIndex] - tables.indexOffset;
304 final int prefixIndex = nsUriIndex2prefixIndex[name.nsUriIndex];
305
306 if (qNameIndex >= 0 &&
307 tables.elementIndexPrefixes[name.qNameIndex] == prefixIndex) {
308 fiout.writeLowLevelStartElementIndexed(0, qNameIndex);
309 } else {
310 tables.elementIndexes[name.qNameIndex] = fiout.getNextElementIndex() + tables.indexOffset;
311 tables.elementIndexPrefixes[name.qNameIndex] = prefixIndex;
312 writeLiteral(EncodingConstants.ELEMENT_LITERAL_QNAME_FLAG,
313 name,
314 nsContext.getPrefix(prefixIndex),
315 nsContext.getNamespaceURI(prefixIndex));
316 }
317 }
318
319 @Override
320 public void attribute(Name name, String value) throws IOException {
321 fiout.writeLowLevelStartAttributes();
322
323 final int qNameIndex = tables.attributeIndexes[name.qNameIndex] - tables.indexOffset;
324 if (qNameIndex >= 0) {
325 fiout.writeLowLevelAttributeIndexed(qNameIndex);
326 } else {
327 tables.attributeIndexes[name.qNameIndex] = fiout.getNextAttributeIndex() + tables.indexOffset;
328
329 final int namespaceURIId = name.nsUriIndex;
330 if (namespaceURIId == -1) {
331 writeLiteral(EncodingConstants.ATTRIBUTE_LITERAL_QNAME_FLAG,
332 name,
333 "",
334 "");
335 } else {
336 final int prefix = nsUriIndex2prefixIndex[namespaceURIId];
337 writeLiteral(EncodingConstants.ATTRIBUTE_LITERAL_QNAME_FLAG,
338 name,
339 nsContext.getPrefix(prefix),
340 nsContext.getNamespaceURI(prefix));
341 }
342 }
343
344 fiout.writeLowLevelAttributeValue(value);
345 }
346
347 private void writeLiteral(int type, Name name, String prefix, String namespaceURI) throws IOException {
348 final int localNameIndex = tables.localNameIndexes[name.localNameIndex] - tables.indexOffset;
349
350 if (localNameIndex < 0) {
351 tables.localNameIndexes[name.localNameIndex] = fiout.getNextLocalNameIndex() + tables.indexOffset;
352
353 fiout.writeLowLevelStartNameLiteral(
354 type,
355 prefix,
356 localNames[name.localNameIndex].buf,
357 namespaceURI);
358 } else {
359 fiout.writeLowLevelStartNameLiteral(
360 type,
361 prefix,
362 localNameIndex,
363 namespaceURI);
364 }
365 }
366
367 @Override
368 public void endStartTag() throws IOException {
369 fiout.writeLowLevelEndStartElement();
370 }
371
372 @Override
373 public void endTag(Name name) throws IOException {
374 fiout.writeLowLevelEndElement();
375 }
376
377 @Override
378 public void endTag(int prefix, String localName) throws IOException {
379 fiout.writeLowLevelEndElement();
380 }
381
382
383 @Override
384 public void text(Pcdata value, boolean needsSeparatingWhitespace) throws IOException {
385 if (needsSeparatingWhitespace)
386 fiout.writeLowLevelText(" ");
387
388 /*
389 * Check if the CharSequence is from a base64Binary data type
390 */
391 if (!(value instanceof Base64Data)) {
392 final int len = value.length();
393 if(len <buf.length) {
394 value.writeTo(buf, 0);
395 fiout.writeLowLevelText(buf, len);
396 } else {
397 fiout.writeLowLevelText(value.toString());
398 }
399 } else {
400 final Base64Data dataValue = (Base64Data)value;
401 // Write out the octets using the base64 encoding algorithm
402 fiout.writeLowLevelOctets(dataValue.get(), dataValue.getDataLen());
403 }
404 }
405
406
407 @Override
408 public void text(String value, boolean needsSeparatingWhitespace) throws IOException {
409 if (needsSeparatingWhitespace)
410 fiout.writeLowLevelText(" ");
411
412 fiout.writeLowLevelText(value);
413 }
414
415
416 @Override
417 public void beginStartTag(int prefix, String localName) throws IOException {
418 fiout.writeLowLevelTerminationAndMark();
419
420 int type = EncodingConstants.ELEMENT;
421 if (nsContext.getCurrent().count() > 0) {
422 final NamespaceContextImpl.Element nse = nsContext.getCurrent();
423
424 fiout.writeLowLevelStartNamespaces();
425 for (int i = nse.count() - 1; i >= 0; i--) {
426 final String uri = nse.getNsUri(i);
427 if (uri.length() == 0 && nse.getBase() == 1)
428 continue; // no point in definint xmlns='' on the root
429 fiout.writeLowLevelNamespace(nse.getPrefix(i), uri);
430 }
431 fiout.writeLowLevelEndNamespaces();
432
433 type= 0;
434 }
435
436 final boolean isIndexed = fiout.writeLowLevelStartElement(
437 type,
438 nsContext.getPrefix(prefix),
439 localName,
440 nsContext.getNamespaceURI(prefix));
441
442 if (!isIndexed)
443 tables.incrementMaxIndexValue();
444 }
445
446 @Override
447 public void attribute(int prefix, String localName, String value) throws IOException {
448 fiout.writeLowLevelStartAttributes();
449
450 boolean isIndexed;
451 if (prefix == -1)
452 isIndexed = fiout.writeLowLevelAttribute("", "", localName);
453 else
454 isIndexed = fiout.writeLowLevelAttribute(
455 nsContext.getPrefix(prefix),
456 nsContext.getNamespaceURI(prefix),
457 localName);
458
459 if (!isIndexed)
460 tables.incrementMaxIndexValue();
461
462 fiout.writeLowLevelAttributeValue(value);
463 }
464 }