jdk8-mips64-public/jaxws: comparison src/share/jaxws_classes/com/sun/xml/internal/ws/encoding/SOAPBindingCodec.java

-:8c0b6bccfe47
+:0989ad8c0860
 /*
-* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2013, 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
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.lang.reflect.Method;
 import java.nio.channels.ReadableByteChannel;
 import java.nio.channels.WritableByteChannel;
-import java.util.StringTokenizer;
+//import java.util.StringTokenizer;
 /**
 * SOAP binding {@link Codec} that can handle MTOM, SwA, and SOAP messages
 * encoded using XML or Fast Infoset.
 *
 public class SOAPBindingCodec extends MimeCodec implements com.sun.xml.internal.ws.api.pipe.SOAPBindingCodec {
 public static final String UTF8_ENCODING = "utf-8";
 public static final String DEFAULT_ENCODING = UTF8_ENCODING;
-/**
-* Based on request's Accept header this is set.
-* Currently only set if MTOMFeature is enabled.
-*
-* Should be used on server-side, for encoding the response.
-*/
-private boolean acceptMtomMessages;
-/**
-* If the request's Content-Type is multipart/related; type=application/xop+xml, then this set to to true
-*
-* Used on server-side, for encoding the repsonse.
-*/
-private boolean isRequestMtomMessage;
-private enum TriState {UNSET,TRUE,FALSE}
-/**
-* This captures is decode is called before encode,
-*  if true, infers that this is being used on Server-side
-*/
-private TriState decodeFirst = TriState.UNSET;
 /**
 * True if Fast Infoset functionality has been
 * configured to be disabled, or the Fast Infoset
 * runtime is not available.
 private final MimeCodec xmlSwaCodec;
 // The Fast Infoset SWA codec
 private final MimeCodec fiSwaCodec;
-//  private final SOAPBindingImpl binding;
-//    private final WebServiceFeature[] feature;
 /**
 * The XML SOAP MIME type
 */
 private final String xmlMimeType;
 public StreamSOAPCodec getXMLCodec() {
 return xmlSoapCodec;
 }
-private class AcceptContentType implements ContentType {
+private ContentTypeImpl setAcceptHeader(Packet p, ContentTypeImpl c) {
-private ContentType _c;
+String _accept;
-private String _accept;
+if (!ignoreContentNegotiationProperty && p.contentNegotiation != ContentNegotiation.none) {
+_accept = connegXmlAccept;
-public AcceptContentType set(Packet p, ContentType c) {
+} else {
-if (!ignoreContentNegotiationProperty && p.contentNegotiation != ContentNegotiation.none) {
+_accept = xmlAccept;
-_accept = connegXmlAccept;
+}
-} else {
+c.setAcceptHeader(_accept);
-_accept = xmlAccept;
+return c;
 }
-_c = c;
-return this;
-}
-public String getContentType() {
-return _c.getContentType();
-}
-public String getSOAPActionHeader() {
-return _c.getSOAPActionHeader();
-}
-public String getAcceptHeader() {
-return _accept;
-}
-}
-private AcceptContentType _adaptingContentType = new AcceptContentType();
 public SOAPBindingCodec(WSFeatureList features) {
 this(features, Codecs.createSOAPEnvelopeXmlCodec(features));
 }
 ignoreContentNegotiationProperty = true;
 }
 xmlAccept = clientAcceptedContentTypes;
-//      if(!(binding instanceof SOAPBindingImpl))
 if(getSoapVersion(features) == null)
 throw new WebServiceException("Expecting a SOAP binding but found ");
-//        this.binding = (SOAPBindingImpl)binding;
 }
 public String getMimeType() {
 return null;
 }
 public ContentType getStaticContentType(Packet packet) {
 ContentType toAdapt = getEncoder(packet).getStaticContentType(packet);
-return (toAdapt != null) ? _adaptingContentType.set(packet, toAdapt) : null;
+return setAcceptHeader(packet, (ContentTypeImpl)toAdapt);
 }
 public ContentType encode(Packet packet, OutputStream out) throws IOException {
 preEncode(packet);
-ContentType ct = _adaptingContentType.set(packet, getEncoder(packet).encode(packet, out));
+ContentType ct = getEncoder(packet).encode(packet, out);
+ct = setAcceptHeader(packet, (ContentTypeImpl)ct);
 postEncode();
 return ct;
 }
 public ContentType encode(Packet packet, WritableByteChannel buffer) {
 preEncode(packet);
-ContentType ct = _adaptingContentType.set(packet, getEncoder(packet).encode(packet, buffer));
+ContentType ct = getEncoder(packet).encode(packet, buffer);
+ct = setAcceptHeader(packet, (ContentTypeImpl)ct);
 postEncode();
 return ct;
 }
 /**
 * Should be called before encode().
 * Set the state so that such state is used by encode process.
 */
 private void preEncode(Packet p) {
-if (decodeFirst == TriState.UNSET)
-decodeFirst = TriState.FALSE;
 }
 /**
 * Should be called after encode()
 * Reset the encoding state.
 */
 private void postEncode() {
-decodeFirst = TriState.UNSET;
-acceptMtomMessages = false;
-isRequestMtomMessage = false;
 }
 /**
 * Should be called before decode().
 * Set the state so that such state is used by decode().
 /**
 * Should be called after decode().
 * Set the state so that such state is used by encode().
 */
 private void postDecode(Packet p) {
-if(decodeFirst == TriState.UNSET)
+p.setFastInfosetDisabled(isFastInfosetDisabled);
-decodeFirst = TriState.TRUE;
+if(features.isEnabled(MTOMFeature.class)) p.checkMtomAcceptable();
-if(features.isEnabled(MTOMFeature.class))
+//            p.setMtomAcceptable( isMtomAcceptable(p.acceptableMimeTypes) );
-acceptMtomMessages =isMtomAcceptable(p.acceptableMimeTypes);
+MTOMFeature mtomFeature = features.get(MTOMFeature.class);
+if (mtomFeature != null) {
+p.setMtomFeature(mtomFeature);
+}
 if (!useFastInfosetForEncoding) {
-useFastInfosetForEncoding = isFastInfosetAcceptable(p.acceptableMimeTypes);
+useFastInfosetForEncoding = p.getFastInfosetAcceptable(fiMimeType);
-}
+//          useFastInfosetForEncoding = isFastInfosetAcceptable(p.acceptableMimeTypes);
 }
-private boolean isServerSide() {
-return decodeFirst ==  TriState.TRUE;
 }
 public void decode(InputStream in, String contentType, Packet packet) throws IOException {
 if (contentType == null) {
 contentType = xmlMimeType;
 }
+packet.setContentType(new ContentTypeImpl(contentType));
 preDecode(packet);
 try {
 if(isMultipartRelated(contentType))
 // parse the multipart portion and then decide whether it's MTOM or SwA
 super.decode(in, contentType, packet);
 @Override
 protected void decode(MimeMultipartParser mpp, Packet packet) throws IOException {
 // is this SwA or XOP?
 final String rootContentType = mpp.getRootPart().getContentType();
+boolean isMTOM = isApplicationXopXml(rootContentType);
-if(isApplicationXopXml(rootContentType)) {
+packet.setMtomRequest(isMTOM);
-isRequestMtomMessage = true;
+if(isMTOM) {
 xmlMtomCodec.decode(mpp,packet);
 } else if (isFastInfoset(rootContentType)) {
 if (packet.contentNegotiation == ContentNegotiation.none)
 throw noFastInfosetForDecoding();
 b.equalsIgnoreCase(
 a.substring(0,
 b.length()));
 }
-private boolean isFastInfosetAcceptable(String accept) {
+//    private boolean isFastInfosetAcceptable(String accept) {
-if (accept == null || isFastInfosetDisabled) return false;
+//        if (accept == null || isFastInfosetDisabled) return false;
+//
-StringTokenizer st = new StringTokenizer(accept, ",");
+//        StringTokenizer st = new StringTokenizer(accept, ",");
-while (st.hasMoreTokens()) {
+//        while (st.hasMoreTokens()) {
-final String token = st.nextToken().trim();
+//            final String token = st.nextToken().trim();
-if (token.equalsIgnoreCase(fiMimeType)) {
+//            if (token.equalsIgnoreCase(fiMimeType)) {
-return true;
+//                return true;
-}
+//            }
-}
+//        }
-return false;
+//        return false;
-}
+//    }
 /*
 * Just check if the Accept header contains application/xop+xml,
 * no need to worry about q values.
 */
-private boolean isMtomAcceptable(String accept) {
+//    private boolean isMtomAcceptable(String accept) {
-if (accept == null || isFastInfosetDisabled) return false;
+//        if (accept == null || isFastInfosetDisabled) return false;
+//        StringTokenizer st = new StringTokenizer(accept, ",");
-StringTokenizer st = new StringTokenizer(accept, ",");
+//        while (st.hasMoreTokens()) {
-while (st.hasMoreTokens()) {
+//            final String token = st.nextToken().trim();
-final String token = st.nextToken().trim();
+//            if (token.toLowerCase().contains(MtomCodec.XOP_XML_MIME_TYPE)) {
-if (token.toLowerCase().contains(MtomCodec.XOP_XML_MIME_TYPE)) {
+//                return true;
-return true;
+//            }
-}
+//        }
-}
+//        return false;
-return false;
+//    }
-}
 /**
 * Determines the encoding codec.
 */
 private Codec getEncoder(Packet p) {
 return fiSoapCodec;
 else
 return fiSwaCodec;
 }
-if(features.isEnabled(MTOMFeature.class)) {
+//If the packet does not have a binding, explicitly set the MTOMFeature
-//On client, always use XOP encoding if MTOM is enabled
+//on the packet so that it has a way to determine whether to use MTOM
-// On Server, use XOP encoding if either request is XOP encoded or client accepts XOP encoding
+if (p.getBinding() == null) {
-if(!isServerSide() || isRequestMtomMessage || acceptMtomMessages)
+if (features != null) {
-return xmlMtomCodec;
+p.setMtomFeature(features.get(MTOMFeature.class));
+}
+}
+if (p.shouldUseMtom()) {
+return xmlMtomCodec;
 }
 Message m = p.getMessage();
 if(m==null || m.getAttachments().isEmpty())
 return xmlSoapCodec;

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

comparison: src/share/jaxws_classes/com/sun/xml/internal/ws/encoding/SOAPBindingCodec.java

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