jdk8-mips64-public/jaxws: comparison src/share/jaxws_classes/com/sun/xml/internal/bind/v2/runtime/output/FastInfosetStreamWriterOutput.java

--1:000000000000
+:373ffda63c9a
+/*
+* 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);
+}
+}

Mercurial > jdk8-mips64-public > jaxws / file comparison

comparison: src/share/jaxws_classes/com/sun/xml/internal/bind/v2/runtime/output/FastInfosetStreamWriterOutput.java

src/share/jaxws_classes/com/sun/xml/internal/bind/v2/runtime/output/FastInfosetStreamWriterOutput.java