jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/xml/internal/ws/encoding/fastinfoset/FastInfosetCodec.java@f50545b5e2f1 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/encoding/fastinfoset/FastInfosetCodec.java@f50545b5e2f1 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/encoding/fastinfoset/FastInfosetCodec.java

Tue, 06 Mar 2012 16:09:35 -0800

author: ohair
date: Tue, 06 Mar 2012 16:09:35 -0800
changeset 286: f50545b5e2f1
child 368: 0989ad8c0860
permissions: -rw-r--r--

7150322: Stop using drop source bundles in jaxws
Reviewed-by: darcy, ohrstrom

 /*
  * Copyright (c) 1997, 2010, 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.ws.encoding.fastinfoset;
 import com.sun.xml.internal.fastinfoset.stax.StAXDocumentSerializer;
 import com.sun.xml.internal.fastinfoset.stax.StAXDocumentParser;
 import com.sun.xml.internal.fastinfoset.vocab.ParserVocabulary;
 import com.sun.xml.internal.fastinfoset.vocab.SerializerVocabulary;
 import com.sun.xml.internal.ws.api.SOAPVersion;
 import com.sun.xml.internal.ws.api.message.Message;
 import com.sun.xml.internal.ws.api.message.Messages;
 import com.sun.xml.internal.ws.api.pipe.Codec;
 import com.sun.xml.internal.ws.api.pipe.ContentType;
 import com.sun.xml.internal.ws.api.message.Packet;
 import com.sun.xml.internal.ws.encoding.ContentTypeImpl;
 import java.io.BufferedInputStream;
 import javax.xml.stream.XMLStreamException;
 import javax.xml.stream.XMLStreamWriter;
 import javax.xml.stream.XMLStreamReader;
 import javax.xml.ws.WebServiceException;
 import java.io.OutputStream;
 import java.io.InputStream;
 import java.io.IOException;
 import java.nio.channels.WritableByteChannel;
 import java.nio.channels.ReadableByteChannel;
 import com.sun.xml.internal.org.jvnet.fastinfoset.FastInfosetSource;
 /**
  * A codec for encoding/decoding XML infosets to/from fast
  * infoset documents.
  *
  * @author Paul Sandoz
  */
 public class FastInfosetCodec implements Codec {
     private static final int DEFAULT_INDEXED_STRING_SIZE_LIMIT = 32;
     private static final int DEFAULT_INDEXED_STRING_MEMORY_LIMIT = 4 * 1024 * 1024; //4M limit
     private StAXDocumentParser _parser;
     private StAXDocumentSerializer _serializer;
     private final boolean _retainState;
     private final ContentType _contentType;
     /* package */ FastInfosetCodec(boolean retainState) {
         _retainState = retainState;
         _contentType = (retainState) ? new ContentTypeImpl(FastInfosetMIMETypes.STATEFUL_INFOSET) :
             new ContentTypeImpl(FastInfosetMIMETypes.INFOSET);
     }
     public String getMimeType() {
         return _contentType.getContentType();
     }
     public Codec copy() {
         return new FastInfosetCodec(_retainState);
     }
     public ContentType getStaticContentType(Packet packet) {
         return _contentType;
     }
     public ContentType encode(Packet packet, OutputStream out) {
         Message message = packet.getMessage();
         if (message != null && message.hasPayload()) {
             final XMLStreamWriter writer = getXMLStreamWriter(out);
             try {
                 writer.writeStartDocument();
                 packet.getMessage().writePayloadTo(writer);
                 writer.writeEndDocument();
                 writer.flush();
             } catch (XMLStreamException e) {
                 throw new WebServiceException(e);
             }
         }
         return _contentType;
     }
     public ContentType encode(Packet packet, WritableByteChannel buffer) {
         //TODO: not yet implemented
         throw new UnsupportedOperationException();
     }
     public void decode(InputStream in, String contentType, Packet packet) throws IOException {
         /* Implements similar logic as the XMLMessage.create(String, InputStream).
          * But it's faster, as we know the InputStream has FastInfoset content*/
         Message message = null;
         in = hasSomeData(in);
         if (in != null) {
             message = Messages.createUsingPayload(new FastInfosetSource(in),
                     SOAPVersion.SOAP_11);
         } else {
             message = Messages.createEmpty(SOAPVersion.SOAP_11);
         }
         packet.setMessage(message);
     }
     public void decode(ReadableByteChannel in, String contentType, Packet response) {
         throw new UnsupportedOperationException();
     }
     private XMLStreamWriter getXMLStreamWriter(OutputStream out) {
         if (_serializer != null) {
             _serializer.setOutputStream(out);
             return _serializer;
         } else {
             return _serializer = createNewStreamWriter(out, _retainState);
         }
     }
     private XMLStreamReader getXMLStreamReader(InputStream in) {
         if (_parser != null) {
             _parser.setInputStream(in);
             return _parser;
         } else {
             return _parser = createNewStreamReader(in, _retainState);
         }
     }
     /**
      * Creates a new {@link FastInfosetCodec} instance.
      *
      * @return a new {@link FastInfosetCodec} instance.
      */
     public static FastInfosetCodec create() {
         return create(false);
     }
     /**
      * Creates a new {@link FastInfosetCodec} instance.
      *
      * @param retainState if true the Codec should retain the state of
      *        vocabulary tables for multiple encode/decode invocations.
      * @return a new {@link FastInfosetCodec} instance.
      */
     public static FastInfosetCodec create(boolean retainState) {
         return new FastInfosetCodec(retainState);
     }
     /**
      * Create a new (@link StAXDocumentSerializer} instance.
      *
      * @param in the OutputStream to serialize to.
      * @param retainState if true the serializer should retain the state of
      *        vocabulary tables for multiple serializations.
      * @return a new {@link StAXDocumentSerializer} instance.
      */
     /* package */ static StAXDocumentSerializer createNewStreamWriter(OutputStream out, boolean retainState) {
         return createNewStreamWriter(out, retainState, DEFAULT_INDEXED_STRING_SIZE_LIMIT, DEFAULT_INDEXED_STRING_MEMORY_LIMIT);
     }
     /**
      * Create a new (@link StAXDocumentSerializer} instance.
      *
      * @param in the OutputStream to serialize to.
      * @param retainState if true the serializer should retain the state of
      *        vocabulary tables for multiple serializations.
      * @return a new {@link StAXDocumentSerializer} instance.
      */
     /* package */ static StAXDocumentSerializer createNewStreamWriter(OutputStream out,
             boolean retainState, int indexedStringSizeLimit, int stringsMemoryLimit) {
         StAXDocumentSerializer serializer = new StAXDocumentSerializer(out);
         if (retainState) {
             /**
              * Create a serializer vocabulary external to the serializer.
              * This will ensure that the vocabulary will never be cleared
              * for each serialization and will be retained (and will grow)
              * for each serialization
              */
             SerializerVocabulary vocabulary = new SerializerVocabulary();
             serializer.setVocabulary(vocabulary);
             serializer.setMinAttributeValueSize(0);
             serializer.setMaxAttributeValueSize(indexedStringSizeLimit);
             serializer.setMinCharacterContentChunkSize(0);
             serializer.setMaxCharacterContentChunkSize(indexedStringSizeLimit);
             serializer.setAttributeValueMapMemoryLimit(stringsMemoryLimit);
             serializer.setCharacterContentChunkMapMemoryLimit(stringsMemoryLimit);
         }
         return serializer;
     }
     /**
      * Create a new (@link StAXDocumentParser} instance.
      *
      * @param in the InputStream to parse from.
      * @param retainState if true the parser should retain the state of
      *        vocabulary tables for multiple parses.
      * @return a new {@link StAXDocumentParser} instance.
      */
     /* package */ static StAXDocumentParser createNewStreamReader(InputStream in, boolean retainState) {
         StAXDocumentParser parser = new StAXDocumentParser(in);
         parser.setStringInterning(true);
         if (retainState) {
             /**
              * Create a parser vocabulary external to the parser.
              * This will ensure that the vocabulary will never be cleared
              * for each parse and will be retained (and will grow)
              * for each parse.
              */
             ParserVocabulary vocabulary = new ParserVocabulary();
             parser.setVocabulary(vocabulary);
         }
         return parser;
     }
     /**
      * Create a new (@link StAXDocumentParser} recyclable instance.
      *
      * @param in the InputStream to parse from.
      * @param retainState if true the parser should retain the state of
      *        vocabulary tables for multiple parses.
      * @return a new recyclable {@link StAXDocumentParser} instance.
      */
     /* package */ static StAXDocumentParser createNewStreamReaderRecyclable(InputStream in, boolean retainState) {
         StAXDocumentParser parser = new FastInfosetStreamReaderRecyclable(in);
         parser.setStringInterning(true);
         parser.setForceStreamClose(true);
         if (retainState) {
             /**
              * Create a parser vocabulary external to the parser.
              * This will ensure that the vocabulary will never be cleared
              * for each parse and will be retained (and will grow)
              * for each parse.
              */
             ParserVocabulary vocabulary = new ParserVocabulary();
             parser.setVocabulary(vocabulary);
         }
         return parser;
     }
     /**
      * Method is copied from com.sun.xml.internal.ws.encoding.xml.XMLMessage
      * @TODO method should be public in some util package?
      *
      * Finds if the stream has some content or not
      *
      * @return null if there is no data
      *         else stream to be used
      */
     private static InputStream hasSomeData(InputStream in) throws IOException {
         if (in != null) {
             if (in.available() < 1) {
                 if (!in.markSupported()) {
                     in = new BufferedInputStream(in);
                 }
                 in.mark(1);
                 if (in.read() != -1) {
                     in.reset();
                 } else {
                     in = null;          // No data
                 }
             }
         }
         return in;
     }
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/com/sun/xml/internal/ws/encoding/fastinfoset/FastInfosetCodec.java@f50545b5e2f1 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/encoding/fastinfoset/FastInfosetCodec.java