| /* |
| * Copyright (c) 1997, 2011, 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.bind.v2.runtime.output; |
| |
| import com.sun.xml.internal.bind.v2.runtime.JAXBContextImpl; |
| import com.sun.xml.internal.bind.v2.runtime.Name; |
| import com.sun.xml.internal.bind.v2.runtime.XMLSerializer; |
| import javax.xml.stream.XMLStreamException; |
| |
| import com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data; |
| import com.sun.xml.internal.fastinfoset.EncodingConstants; |
| import com.sun.xml.internal.fastinfoset.stax.StAXDocumentSerializer; |
| import java.io.IOException; |
| import java.util.Collection; |
| import java.util.Map; |
| import java.util.WeakHashMap; |
| import javax.xml.bind.JAXBContext; |
| import com.sun.xml.internal.org.jvnet.fastinfoset.VocabularyApplicationData; |
| import org.xml.sax.SAXException; |
| |
| /** |
| * {@link XmlOutput} for {@link LowLevelStAXDocumentSerializer}. |
| * <p> |
| * This class is responsible for managing the indexing of elements, attributes |
| * and local names that are known to JAXB by way of the JAXBContext (generated |
| * from JAXB beans or schema). The pre-encoded UTF-8 representations of known |
| * local names are also utilized. |
| * <p> |
| * The lookup of elements, attributes and local names with respect to a context |
| * is very efficient. It relies on an incrementing base line so that look up is |
| * performed in O(1) time and only uses static memory. When the base line reaches |
| * a point where integer overflow will occur the arrays and base line are reset |
| * (such an event is rare and will have little impact on performance). |
| * <p> |
| * A weak map of JAXB contexts to optimized tables for attributes, elements and |
| * local names is utilized and stored on the LowLevel StAX serializer. Thus, |
| * optimized serializing can work other multiple serializing of JAXB beans using |
| * the same LowLevel StAX serializer instance. This approach works best when JAXB |
| * contexts are only created once per schema or JAXB beans (which is the recommended |
| * practice as the creation JAXB contexts are expensive, they are thread safe and |
| * can be reused). |
| * |
| * @author Paul.Sandoz@Sun.Com |
| */ |
| public final class FastInfosetStreamWriterOutput extends XMLStreamWriterOutput { |
| private final StAXDocumentSerializer fiout; |
| private final Encoded[] localNames; |
| private final TablesPerJAXBContext tables; |
| |
| /** |
| * Holder for the optimzed element, attribute and |
| * local name tables. |
| */ |
| final static class TablesPerJAXBContext { |
| final int[] elementIndexes; |
| final int[] elementIndexPrefixes; |
| |
| final int[] attributeIndexes; |
| final int[] localNameIndexes; |
| |
| /** |
| * The offset of the index |
| */ |
| int indexOffset; |
| |
| /** |
| * The the maximum known value of an index |
| */ |
| int maxIndex; |
| |
| /** |
| * True if the tables require clearing |
| */ |
| boolean requiresClear; |
| |
| /** |
| * Create a new set of tables for a JAXB context. |
| * <p> |
| * @param content the JAXB context. |
| * @param initialIndexOffset the initial index offset to calculate |
| * the maximum possible index |
| * |
| */ |
| TablesPerJAXBContext(JAXBContextImpl context, int initialIndexOffset) { |
| elementIndexes = new int[context.getNumberOfElementNames()]; |
| elementIndexPrefixes = new int[context.getNumberOfElementNames()]; |
| attributeIndexes = new int[context.getNumberOfAttributeNames()]; |
| localNameIndexes = new int[context.getNumberOfLocalNames()]; |
| |
| indexOffset = 1; |
| maxIndex = initialIndexOffset + elementIndexes.length + attributeIndexes.length; |
| } |
| |
| /** |
| * Require that tables are cleared. |
| */ |
| public void requireClearTables() { |
| requiresClear = true; |
| } |
| |
| /** |
| * Clear or reset the tables. |
| * <p> |
| * @param initialIndexOffset the initial index offset to calculate |
| * the maximum possible index |
| */ |
| public void clearOrResetTables(int intialIndexOffset) { |
| if (requiresClear) { |
| requiresClear = false; |
| |
| // Increment offset to new position |
| indexOffset += maxIndex; |
| // Reset the maximum known value of an index |
| maxIndex = intialIndexOffset + elementIndexes.length + attributeIndexes.length; |
| // Check if there is enough free space |
| // If overflow |
| if ((indexOffset + maxIndex) < 0) { |
| clearAll(); |
| } |
| } else { |
| // Reset the maximum known value of an index |
| maxIndex = intialIndexOffset + elementIndexes.length + attributeIndexes.length; |
| // Check if there is enough free space |
| // If overflow |
| if ((indexOffset + maxIndex) < 0) { |
| resetAll(); |
| } |
| } |
| } |
| |
| private void clearAll() { |
| clear(elementIndexes); |
| clear(attributeIndexes); |
| clear(localNameIndexes); |
| indexOffset = 1; |
| } |
| |
| private void clear(int[] array) { |
| for (int i = 0; i < array.length; i++) { |
| array[i] = 0; |
| } |
| } |
| |
| /** |
| * Increment the maximum know index value |
| * <p> |
| * The indexes are preserved. |
| */ |
| public void incrementMaxIndexValue() { |
| // Increment the maximum value of an index |
| maxIndex++; |
| // Check if there is enough free space |
| // If overflow |
| if ((indexOffset + maxIndex) < 0) { |
| resetAll(); |
| } |
| } |
| |
| private void resetAll() { |
| clear(elementIndexes); |
| clear(attributeIndexes); |
| clear(localNameIndexes); |
| indexOffset = 1; |
| } |
| |
| private void reset(int[] array) { |
| for (int i = 0; i < array.length; i++) { |
| if (array[i] > indexOffset) { |
| array[i] = array[i] - indexOffset + 1; |
| } else { |
| array[i] = 0; |
| } |
| } |
| } |
| |
| } |
| |
| /** |
| * Holder of JAXB contexts -> tables. |
| * <p> |
| * An instance will be registered with the |
| * {@link LowLevelStAXDocumentSerializer}. |
| */ |
| final static class AppData implements VocabularyApplicationData { |
| final Map<JAXBContext, TablesPerJAXBContext> contexts = |
| new WeakHashMap<JAXBContext, TablesPerJAXBContext>(); |
| final Collection<TablesPerJAXBContext> collectionOfContexts = contexts.values(); |
| |
| /** |
| * Clear all the tables. |
| */ |
| public void clear() { |
| for(TablesPerJAXBContext c : collectionOfContexts) |
| c.requireClearTables(); |
| } |
| } |
| |
| public FastInfosetStreamWriterOutput(StAXDocumentSerializer out, |
| JAXBContextImpl context) { |
| super(out); |
| |
| this.fiout = out; |
| this.localNames = context.getUTF8NameTable(); |
| |
| final VocabularyApplicationData vocabAppData = fiout.getVocabularyApplicationData(); |
| AppData appData = null; |
| if (vocabAppData == null || !(vocabAppData instanceof AppData)) { |
| appData = new AppData(); |
| fiout.setVocabularyApplicationData(appData); |
| } else { |
| appData = (AppData)vocabAppData; |
| } |
| |
| final TablesPerJAXBContext tablesPerContext = appData.contexts.get(context); |
| if (tablesPerContext != null) { |
| tables = tablesPerContext; |
| /** |
| * Obtain the current local name index. Thus will be used to |
| * calculate the maximum index value when serializing for this context |
| */ |
| tables.clearOrResetTables(out.getLocalNameIndex()); |
| } else { |
| tables = new TablesPerJAXBContext(context, out.getLocalNameIndex()); |
| appData.contexts.put(context, tables); |
| } |
| } |
| |
| @Override |
| public void startDocument(XMLSerializer serializer, boolean fragment, |
| int[] nsUriIndex2prefixIndex, NamespaceContextImpl nsContext) |
| throws IOException, SAXException, XMLStreamException { |
| super.startDocument(serializer, fragment, nsUriIndex2prefixIndex, nsContext); |
| |
| if (fragment) |
| fiout.initiateLowLevelWriting(); |
| } |
| |
| @Override |
| public void endDocument(boolean fragment) throws IOException, SAXException, XMLStreamException { |
| super.endDocument(fragment); |
| } |
| |
| @Override |
| public void beginStartTag(Name name) throws IOException { |
| fiout.writeLowLevelTerminationAndMark(); |
| |
| if (nsContext.getCurrent().count() == 0) { |
| final int qNameIndex = tables.elementIndexes[name.qNameIndex] - tables.indexOffset; |
| final int prefixIndex = nsUriIndex2prefixIndex[name.nsUriIndex]; |
| |
| if (qNameIndex >= 0 && |
| tables.elementIndexPrefixes[name.qNameIndex] == prefixIndex) { |
| fiout.writeLowLevelStartElementIndexed(EncodingConstants.ELEMENT, qNameIndex); |
| } else { |
| tables.elementIndexes[name.qNameIndex] = fiout.getNextElementIndex() + tables.indexOffset; |
| tables.elementIndexPrefixes[name.qNameIndex] = prefixIndex; |
| writeLiteral(EncodingConstants.ELEMENT | EncodingConstants.ELEMENT_LITERAL_QNAME_FLAG, |
| name, |
| nsContext.getPrefix(prefixIndex), |
| nsContext.getNamespaceURI(prefixIndex)); |
| } |
| } else { |
| beginStartTagWithNamespaces(name); |
| } |
| } |
| |
| public void beginStartTagWithNamespaces(Name name) throws IOException { |
| final NamespaceContextImpl.Element nse = nsContext.getCurrent(); |
| |
| fiout.writeLowLevelStartNamespaces(); |
| for (int i = nse.count() - 1; i >= 0; i--) { |
| final String uri = nse.getNsUri(i); |
| if (uri.length() == 0 && nse.getBase() == 1) |
| continue; // no point in definint xmlns='' on the root |
| fiout.writeLowLevelNamespace(nse.getPrefix(i), uri); |
| } |
| fiout.writeLowLevelEndNamespaces(); |
| |
| final int qNameIndex = tables.elementIndexes[name.qNameIndex] - tables.indexOffset; |
| final int prefixIndex = nsUriIndex2prefixIndex[name.nsUriIndex]; |
| |
| if (qNameIndex >= 0 && |
| tables.elementIndexPrefixes[name.qNameIndex] == prefixIndex) { |
| fiout.writeLowLevelStartElementIndexed(0, qNameIndex); |
| } else { |
| tables.elementIndexes[name.qNameIndex] = fiout.getNextElementIndex() + tables.indexOffset; |
| tables.elementIndexPrefixes[name.qNameIndex] = prefixIndex; |
| writeLiteral(EncodingConstants.ELEMENT_LITERAL_QNAME_FLAG, |
| name, |
| nsContext.getPrefix(prefixIndex), |
| nsContext.getNamespaceURI(prefixIndex)); |
| } |
| } |
| |
| @Override |
| public void attribute(Name name, String value) throws IOException { |
| fiout.writeLowLevelStartAttributes(); |
| |
| final int qNameIndex = tables.attributeIndexes[name.qNameIndex] - tables.indexOffset; |
| if (qNameIndex >= 0) { |
| fiout.writeLowLevelAttributeIndexed(qNameIndex); |
| } else { |
| tables.attributeIndexes[name.qNameIndex] = fiout.getNextAttributeIndex() + tables.indexOffset; |
| |
| final int namespaceURIId = name.nsUriIndex; |
| if (namespaceURIId == -1) { |
| writeLiteral(EncodingConstants.ATTRIBUTE_LITERAL_QNAME_FLAG, |
| name, |
| "", |
| ""); |
| } else { |
| final int prefix = nsUriIndex2prefixIndex[namespaceURIId]; |
| writeLiteral(EncodingConstants.ATTRIBUTE_LITERAL_QNAME_FLAG, |
| name, |
| nsContext.getPrefix(prefix), |
| nsContext.getNamespaceURI(prefix)); |
| } |
| } |
| |
| fiout.writeLowLevelAttributeValue(value); |
| } |
| |
| private void writeLiteral(int type, Name name, String prefix, String namespaceURI) throws IOException { |
| final int localNameIndex = tables.localNameIndexes[name.localNameIndex] - tables.indexOffset; |
| |
| if (localNameIndex < 0) { |
| tables.localNameIndexes[name.localNameIndex] = fiout.getNextLocalNameIndex() + tables.indexOffset; |
| |
| fiout.writeLowLevelStartNameLiteral( |
| type, |
| prefix, |
| localNames[name.localNameIndex].buf, |
| namespaceURI); |
| } else { |
| fiout.writeLowLevelStartNameLiteral( |
| type, |
| prefix, |
| localNameIndex, |
| namespaceURI); |
| } |
| } |
| |
| @Override |
| public void endStartTag() throws IOException { |
| fiout.writeLowLevelEndStartElement(); |
| } |
| |
| @Override |
| public void endTag(Name name) throws IOException { |
| fiout.writeLowLevelEndElement(); |
| } |
| |
| @Override |
| public void endTag(int prefix, String localName) throws IOException { |
| fiout.writeLowLevelEndElement(); |
| } |
| |
| |
| @Override |
| public void text(Pcdata value, boolean needsSeparatingWhitespace) throws IOException { |
| if (needsSeparatingWhitespace) |
| fiout.writeLowLevelText(" "); |
| |
| /* |
| * Check if the CharSequence is from a base64Binary data type |
| */ |
| if (!(value instanceof Base64Data)) { |
| final int len = value.length(); |
| if(len <buf.length) { |
| value.writeTo(buf, 0); |
| fiout.writeLowLevelText(buf, len); |
| } else { |
| fiout.writeLowLevelText(value.toString()); |
| } |
| } else { |
| final Base64Data dataValue = (Base64Data)value; |
| // Write out the octets using the base64 encoding algorithm |
| fiout.writeLowLevelOctets(dataValue.get(), dataValue.getDataLen()); |
| } |
| } |
| |
| |
| @Override |
| public void text(String value, boolean needsSeparatingWhitespace) throws IOException { |
| if (needsSeparatingWhitespace) |
| fiout.writeLowLevelText(" "); |
| |
| fiout.writeLowLevelText(value); |
| } |
| |
| |
| @Override |
| public void beginStartTag(int prefix, String localName) throws IOException { |
| fiout.writeLowLevelTerminationAndMark(); |
| |
| int type = EncodingConstants.ELEMENT; |
| if (nsContext.getCurrent().count() > 0) { |
| final NamespaceContextImpl.Element nse = nsContext.getCurrent(); |
| |
| fiout.writeLowLevelStartNamespaces(); |
| for (int i = nse.count() - 1; i >= 0; i--) { |
| final String uri = nse.getNsUri(i); |
| if (uri.length() == 0 && nse.getBase() == 1) |
| continue; // no point in definint xmlns='' on the root |
| fiout.writeLowLevelNamespace(nse.getPrefix(i), uri); |
| } |
| fiout.writeLowLevelEndNamespaces(); |
| |
| type= 0; |
| } |
| |
| final boolean isIndexed = fiout.writeLowLevelStartElement( |
| type, |
| nsContext.getPrefix(prefix), |
| localName, |
| nsContext.getNamespaceURI(prefix)); |
| |
| if (!isIndexed) |
| tables.incrementMaxIndexValue(); |
| } |
| |
| @Override |
| public void attribute(int prefix, String localName, String value) throws IOException { |
| fiout.writeLowLevelStartAttributes(); |
| |
| boolean isIndexed; |
| if (prefix == -1) |
| isIndexed = fiout.writeLowLevelAttribute("", "", localName); |
| else |
| isIndexed = fiout.writeLowLevelAttribute( |
| nsContext.getPrefix(prefix), |
| nsContext.getNamespaceURI(prefix), |
| localName); |
| |
| if (!isIndexed) |
| tables.incrementMaxIndexValue(); |
| |
| fiout.writeLowLevelAttributeValue(value); |
| } |
| } |
