jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/xml/internal/ws/api/message/Packet.java@8f2986ff0235 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/message/Packet.java@8f2986ff0235 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/message/Packet.java

Wed, 12 Jun 2013 14:47:09 +0100

author: mkos
date: Wed, 12 Jun 2013 14:47:09 +0100
changeset 384: 8f2986ff0235
parent 368: 0989ad8c0860
child 397: b99d7e355d4b
permissions: -rw-r--r--

8013021: Rebase 8005432 & 8003542 against the latest jdk8/jaxws
8003542: Improve processing of MTOM attachments
8005432: Update access to JAX-WS
Reviewed-by: mullan

 /*
  * 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
  * 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.api.message;
 import com.oracle.webservices.internal.api.message.ContentType;
 import com.oracle.webservices.internal.api.message.PropertySet;
 import com.sun.istack.internal.NotNull;
 import com.sun.istack.internal.Nullable;
 import com.sun.xml.internal.bind.marshaller.SAX2DOMEx;
 import com.sun.xml.internal.ws.addressing.WsaPropertyBag;
 import com.sun.xml.internal.ws.addressing.WsaServerTube;
 import com.sun.xml.internal.ws.addressing.WsaTubeHelper;
 import com.sun.xml.internal.ws.api.Component;
 import com.sun.xml.internal.ws.api.EndpointAddress;
 import com.sun.xml.internal.ws.api.SOAPVersion;
 import com.sun.xml.internal.ws.api.WSBinding;
 import com.sun.xml.internal.ws.api.addressing.AddressingVersion;
 import com.sun.xml.internal.ws.api.addressing.WSEndpointReference;
 import com.sun.xml.internal.ws.api.model.JavaMethod;
 import com.sun.xml.internal.ws.api.model.SEIModel;
 import com.sun.xml.internal.ws.api.model.WSDLOperationMapping;
 import com.sun.xml.internal.ws.api.model.wsdl.WSDLOperation;
 import com.sun.xml.internal.ws.api.model.wsdl.WSDLPort;
 import com.sun.xml.internal.ws.api.pipe.Codec;
 import com.sun.xml.internal.ws.api.pipe.Tube;
 import com.sun.xml.internal.ws.api.server.Adapter;
 import com.sun.xml.internal.ws.api.server.TransportBackChannel;
 import com.sun.xml.internal.ws.api.server.WSEndpoint;
 import com.sun.xml.internal.ws.api.server.WebServiceContextDelegate;
 import com.sun.xml.internal.ws.api.streaming.XMLStreamWriterFactory;
 import com.sun.xml.internal.ws.client.*;
 import com.sun.xml.internal.ws.developer.JAXWSProperties;
 import com.sun.xml.internal.ws.encoding.MtomCodec;
 import com.sun.xml.internal.ws.message.RelatesToHeader;
 import com.sun.xml.internal.ws.message.StringHeader;
 import com.sun.xml.internal.ws.util.DOMUtil;
 import com.sun.xml.internal.ws.util.xml.XmlUtil;
 import com.sun.xml.internal.ws.wsdl.DispatchException;
 import com.sun.xml.internal.ws.wsdl.OperationDispatcher;
 import com.sun.xml.internal.ws.resources.AddressingMessages;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.xml.sax.SAXException;
 import javax.xml.namespace.QName;
 import javax.xml.soap.SOAPException;
 import javax.xml.soap.SOAPMessage;
 import javax.xml.stream.XMLStreamWriter;
 import javax.xml.stream.XMLStreamException;
 import javax.xml.ws.BindingProvider;
 import javax.xml.ws.Dispatch;
 import javax.xml.ws.WebServiceContext;
 import javax.xml.ws.WebServiceException;
 import javax.xml.ws.handler.LogicalMessageContext;
 import javax.xml.ws.handler.MessageContext;
 import javax.xml.ws.handler.soap.SOAPMessageContext;
 import javax.xml.ws.soap.MTOMFeature;
 import java.util.*;
 import java.util.logging.Logger;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.channels.WritableByteChannel;
 /**
  * Represents a container of a {@link Message}.
  *
  * <h2>What is a {@link Packet}?</h2>
  * <p>
  * A packet can be thought of as a frame/envelope/package that wraps
  * a {@link Message}. A packet keeps track of optional metadata (properties)
  * about a {@link Message} that doesn't go across the wire.
  * This roughly corresponds to {@link MessageContext} in the JAX-WS API.
  *
  * <p>
  * Usually a packet contains a {@link Message} in it, but sometimes
  * (such as for a reply of an one-way operation), a packet may
  * float around without a {@link Message} in it.
  *
  *
  * <a name="properties"></a>
  * <h2>Properties</h2>
  * <p>
  * Information frequently used inside the JAX-WS RI
  * is stored in the strongly-typed fields. Other information is stored
  * in terms of a generic {@link Map} (see
  * {@link #invocationProperties}.)
  *
  * <p>
  * Some properties need to be retained between request and response,
  * some don't. For strongly typed fields, this characteristic is
  * statically known for each of them, and propagation happens accordingly.
  * For generic information stored in {@link Map}, {@link #invocationProperties}
  * stores per-invocation scope information (which carries over to
  * the response.)
  *
  * <p>
  * This object is used as the backing store of {@link MessageContext}, and
  * {@link LogicalMessageContext} and {@link SOAPMessageContext} will
  * be delegating to this object for storing/retrieving values.
  *
  *
  * <h3>Relationship to request/response context</h3>
  * <p>
  * {@link BindingProvider#getRequestContext() Request context} is used to
  * seed the initial values of {@link Packet}.
  * Some of those values go to strongly-typed fields, and others go to
  * {@link #invocationProperties}, as they need to be retained in the reply message.
  *
  * <p>
  * Similarly, {@link BindingProvider#getResponseContext() response context}
  * is constructed from {@link Packet} (or rather it's just a view of {@link Packet}.)
  * by using properties from {@link #invocationProperties},
  * modulo properties named explicitly in {@link #getHandlerScopePropertyNames(boolean)}.
  * IOW, properties added to {@link #invocationProperties}
  * are exposed to the response context by default.
  *
  *
  *
  * <h3>TODO</h3>
  * <ol>
  *  <li>this class needs to be cloneable since Message is copiable.
  *  <li>The three live views aren't implemented correctly. It will be
  *      more work to do so, although I'm sure it's possible.
  *  <li>{@link PropertySet.Property} annotation is to make it easy
  *      for {@link MessageContext} to export properties on this object,
  *      but it probably needs some clean up.
  * </ol>
  *
  * @author Kohsuke Kawaguchi
  */
 public final class Packet
         // Packet must continue to extend/implement deprecated interfaces until downstream
         // usage is updated.
     extends com.oracle.webservices.internal.api.message.BaseDistributedPropertySet
     implements com.oracle.webservices.internal.api.message.MessageContext, MessageMetadata {
     /**
      * Creates a {@link Packet} that wraps a given {@link Message}.
      *
      * <p>
      * This method should be only used to create a fresh {@link Packet}.
      * To create a {@link Packet} for a reply, use {@link #createResponse(Message)}.
      *
      * @param request
      *      The request {@link Message}. Can be null.
      */
     public Packet(Message request) {
         this();
         this.message = request;
         if (message != null) message.setMessageMedadata(this);
     }
     /**
      * Creates an empty {@link Packet} that doesn't have any {@link Message}.
      */
     public Packet() {
         this.invocationProperties = new HashMap<String, Object>();
     }
     /**
      * Used by {@link #createResponse(Message)} and {@link #copy(boolean)}.
      */
     private Packet(Packet that) {
         relatePackets(that, true);
         this.invocationProperties = that.invocationProperties;
     }
     /**
      * Creates a copy of this {@link Packet}.
      *
      * @param copyMessage determines whether the {@link Message} from the original {@link Packet} should be copied as
      *        well, or not. If the value is {@code false}, the {@link Message} in the copy of the {@link Packet} is {@code null}.
      * @return copy of the original packet
      */
     public Packet copy(boolean copyMessage) {
         // the copy constructor is originally designed for creating a response packet,
         // but so far the implementation is usable for this purpose as well, so calling the copy constructor
         // to avoid code dupliation.
         Packet copy = new Packet(this);
         if (copyMessage && this.message != null) {
             copy.message = this.message.copy();
         }
         if (copy.message != null) copy.message.setMessageMedadata(copy);
         return copy;
     }
     private Message message;
     /**
      * Gets the last {@link Message} set through {@link #setMessage(Message)}.
      *
      * @return may null. See the class javadoc for when it's null.
      */
     public Message getMessage() {
         if (message != null && !(message instanceof MessageWrapper)) {
             message = new MessageWrapper(this, message);
         }
         return  message;
     }
     public Message getInternalMessage() {
         return (message instanceof MessageWrapper)? ((MessageWrapper)message).delegate : message;
     }
     public WSBinding getBinding() {
         if (endpoint != null) {
             return endpoint.getBinding();
         }
         if (proxy != null) {
             return (WSBinding) proxy.getBinding();
         }
         return null;
     }
     /**
      * Sets a {@link Message} to this packet.
      *
      * @param message Can be null.
      */
     public void setMessage(Message message) {
         this.message = message;
         if (message != null) this.message.setMessageMedadata(this);
     }
     private WSDLOperationMapping wsdlOperationMapping = null;
     private QName wsdlOperation;
     /**
      * Returns the QName of the wsdl operation associated with this packet.
      * <p/>
      * Information such as Payload QName, wsa:Action header, SOAPAction HTTP header are used depending on the features
      * enabled on the particular port.
      *
      * @return null if there is no WSDL model or
      *         runtime cannot uniquely identify the wsdl operation from the information in the packet.
      */
     @Property(MessageContext.WSDL_OPERATION)
     public final
     @Nullable
     QName getWSDLOperation() {
         if (wsdlOperation != null) return wsdlOperation;
         if ( wsdlOperationMapping == null)  wsdlOperationMapping = getWSDLOperationMapping();
         if ( wsdlOperationMapping != null ) wsdlOperation = wsdlOperationMapping.getOperationName();
         return wsdlOperation;
     }
     public WSDLOperationMapping getWSDLOperationMapping() {
         if (wsdlOperationMapping != null) return wsdlOperationMapping;
         OperationDispatcher opDispatcher = null;
         if (endpoint != null) {
             opDispatcher = endpoint.getOperationDispatcher();
         } else if (proxy != null) {
             opDispatcher = ((Stub) proxy).getOperationDispatcher();
         }
         //OpDispatcher is null when there is no WSDLModel
         if (opDispatcher != null) {
             try {
                 wsdlOperationMapping = opDispatcher.getWSDLOperationMapping(this);
             } catch (DispatchException e) {
                 //Ignore, this might be a protocol message which may not have a wsdl operation
                 //LOGGER.info("Cannot resolve wsdl operation that this Packet is targeted for.");
             }
         }
         return wsdlOperationMapping;
     }
     /**
      * Set the wsdl operation to avoid lookup from other data.
      * This is useful in SEI based clients, where the WSDL operation can be known
      * from the associated {@link JavaMethod}
      *
      * @param wsdlOp QName
      */
     public void setWSDLOperation(QName wsdlOp) {
         this.wsdlOperation = wsdlOp;
     }
     /**
      * True if this message came from a transport (IOW inbound),
      * and in paricular from a "secure" transport. A transport
      * needs to set this flag appropriately.
      *
      * <p>
      * This is a requirement from the security team.
      */
     // TODO: expose this as a property
     public boolean wasTransportSecure;
     /**
      * Inbound transport headers are captured in a transport neutral way.
      * Transports are expected to fill this data after creating a Packet.
      * <p>
      * {@link SOAPMessage#getMimeHeaders()} would return these headers.
      */
     public static final String INBOUND_TRANSPORT_HEADERS = "com.sun.xml.internal.ws.api.message.packet.inbound.transport.headers";
     /**
      * Outbound transport headers are captured in a transport neutral way.
      *
      * <p>
      * Transports may choose to ignore certain headers that interfere with
      * its correct operation, such as
      * <tt>Content-Type</tt> and <tt>Content-Length</tt>.
      */
     public static final String OUTBOUND_TRANSPORT_HEADERS = "com.sun.xml.internal.ws.api.message.packet.outbound.transport.headers";
     /**
      *
      */
     public static final String HA_INFO = "com.sun.xml.internal.ws.api.message.packet.hainfo";
     /**
      * This property holds the snapshot of HandlerConfiguration
      * at the time of invocation.
      * This property is used by MUPipe and HandlerPipe implementations.
      */
     @Property(BindingProviderProperties.JAXWS_HANDLER_CONFIG)
     public HandlerConfiguration handlerConfig;
     /**
      * If a message originates from a proxy stub that implements
      * a port interface, this field is set to point to that object.
      *
      * TODO: who's using this property?
      */
     @Property(BindingProviderProperties.JAXWS_CLIENT_HANDLE_PROPERTY)
     public BindingProvider proxy;
     /**
      * Determines if the governing {@link Adapter} or {@link com.sun.xml.internal.ws.api.pipe.Fiber.CompletionCallback}
      * will handle delivering response messages targeted at non-anonymous endpoint
      * addresses.  Prior to the introduction of this flag
      * the {@link WsaServerTube} would deliver non-anonymous responses.
      */
     public boolean isAdapterDeliversNonAnonymousResponse;
     /**
      * During invocation of a client Stub or Dispatch a Packet is
      * created then the Stub's RequestContext is copied into the
      * Packet.  On certain internal cases the Packet is created
      * *before* the invocation.  In those cases we want the contents
      * of the Packet to take precedence when ever any key/value pairs
      * collide : if the Packet contains a value for a key use it,
      * otherwise copy as usual from Stub.
      */
     public boolean packetTakesPriorityOverRequestContext = false;
     /**
      * The endpoint address to which this message is sent to.
      *
      * <p>
      * The JAX-WS spec allows this to be changed for each message,
      * so it's designed to be a property.
      *
      * <p>
      * Must not be null for a request message on the client. Otherwise
      * it's null.
      */
     public EndpointAddress endpointAddress;
     /**
      * @deprecated
      *      The programatic acccess should be done via
      *      {@link #endpointAddress}. This is for JAX-WS client applications
      *      that access this property via {@link BindingProvider#ENDPOINT_ADDRESS_PROPERTY}.
      */
     @Property(BindingProvider.ENDPOINT_ADDRESS_PROPERTY)
     public String getEndPointAddressString() {
         if (endpointAddress == null) {
             return null;
         } else {
             return endpointAddress.toString();
         }
     }
     public void setEndPointAddressString(String s) {
         if (s == null) {
             this.endpointAddress = null;
         } else {
             this.endpointAddress = EndpointAddress.create(s);
         }
     }
     /**
      * The value of {@link ContentNegotiation#PROPERTY}
      * property.
      * <p/>
      * This property is used only on the client side.
      */
     public ContentNegotiation contentNegotiation;
     @Property(ContentNegotiation.PROPERTY)
     public String getContentNegotiationString() {
         return (contentNegotiation != null) ? contentNegotiation.toString() : null;
     }
     public void setContentNegotiationString(String s) {
         if (s == null) {
             contentNegotiation = null;
         } else {
             try {
                 contentNegotiation = ContentNegotiation.valueOf(s);
             } catch (IllegalArgumentException e) {
                 // If the value is not recognized default to none
                 contentNegotiation = ContentNegotiation.none;
             }
         }
     }
     /**
      * Gives a list of Reference Parameters in the Message
      * <p>
      * Headers which have attribute wsa:IsReferenceParameter="true"
      * This is not cached as one may reset the Message.
      *<p>
      */
     @Property(MessageContext.REFERENCE_PARAMETERS)
     public
     @NotNull
     List<Element> getReferenceParameters() {
         Message msg = getMessage();
         List<Element> refParams = new ArrayList<Element>();
         if (msg == null) {
             return refParams;
         }
         MessageHeaders hl = msg.getHeaders();
         for (Header h : hl.asList()) {
             String attr = h.getAttribute(AddressingVersion.W3C.nsUri, "IsReferenceParameter");
             if (attr != null && (attr.equals("true") || attr.equals("1"))) {
                 Document d = DOMUtil.createDom();
                 SAX2DOMEx s2d = new SAX2DOMEx(d);
                 try {
                     h.writeTo(s2d, XmlUtil.DRACONIAN_ERROR_HANDLER);
                     refParams.add((Element) d.getLastChild());
                 } catch (SAXException e) {
                     throw new WebServiceException(e);
                 }
                 /*
                 DOMResult result = new DOMResult(d);
                 XMLDOMWriterImpl domwriter = new XMLDOMWriterImpl(result);
                 try {
                     h.writeTo(domwriter);
                     refParams.add((Element) result.getNode().getLastChild());
                 } catch (XMLStreamException e) {
                     throw new WebServiceException(e);
                 }
                 */
             }
         }
         return refParams;
     }
     /**
      *      This method is for exposing header list through {@link PropertySet#get(Object)},
      *      for user applications, and should never be invoked directly from within the JAX-WS RI.
      */
     @Property(JAXWSProperties.INBOUND_HEADER_LIST_PROPERTY)
     /*package*/ MessageHeaders getHeaderList() {
         Message msg = getMessage();
         if (msg == null) {
             return null;
         }
         return msg.getHeaders();
     }
     /**
      * The list of MIME types that are acceptable to a receiver
      * of an outbound message.
      *
      * This property is used only on the server side.
      *
      * <p>The representation shall be that specified by the HTTP Accept
      * request-header field.
      *
      * <p>The list of content types will be obtained from the transport
      * meta-data of a inbound message in a request/response message exchange.
      * Hence this property will be set by the service-side transport pipe.
      */
     public String acceptableMimeTypes;
     /**
      * When non-null, this object is consulted to
      * implement {@link WebServiceContext} methods
      * exposed to the user application.
      *
      * Used only on the server side.
      *
      * <p>
      * This property is set from the parameter
      * of {@link WSEndpoint.PipeHead#process}.
      */
     public WebServiceContextDelegate webServiceContextDelegate;
     /**
      * Used only on the server side so that the transport
      * can close the connection early.
      *
      * <p>
      * This field can be null. While a message is being processed,
      * this field can be set explicitly to null, to prevent
      * future pipes from closing a transport (see {@link #keepTransportBackChannelOpen()})
      *
      * <p>
      * This property is set from the parameter
      * of {@link WSEndpoint.PipeHead#process}.
      */
     public
     @Nullable
     TransportBackChannel transportBackChannel;
     /**
      * Keeps the transport back channel open (by seeting {@link #transportBackChannel} to null.)
      *
      * @return
      *      The previous value of {@link #transportBackChannel}.
      */
     public TransportBackChannel keepTransportBackChannelOpen() {
         TransportBackChannel r = transportBackChannel;
         transportBackChannel = null;
         return r;
     }
     /**
       * The governing owner of this packet.  On the service-side this is the {@link Adapter} and on the client it is the {@link Stub}.
       *
       */
      public Component component;
     /**
      * The governing {@link WSEndpoint} in which this message is floating.
      *
      * <p>
      * This property is set if and only if this is on the server side.
      */
     @Property(JAXWSProperties.WSENDPOINT)
     public WSEndpoint endpoint;
     /**
      * The value of the SOAPAction header associated with the message.
      *
      * <p>
      * For outgoing messages, the transport may sends out this value.
      * If this field is null, the transport may choose to send <tt>""</tt>
      * (quoted empty string.)
      *
      * For incoming messages, the transport will set this field.
      * If the incoming message did not contain the SOAPAction header,
      * the transport sets this field to null.
      *
      * <p>
      * If the value is non-null, it must be always in the quoted form.
      * The value can be null.
      *
      * <p>
      * Note that the way the transport sends this value out depends on
      * transport and SOAP version.
      * <p/>
      * For HTTP transport and SOAP 1.1, BP requires that SOAPAction
      * header is present (See {@BP R2744} and {@BP R2745}.) For SOAP 1.2,
      * this is moved to the parameter of the "application/soap+xml".
      */
     @Property(BindingProvider.SOAPACTION_URI_PROPERTY)
     public String soapAction;
     /**
      * A hint indicating that whether a transport should expect
      * a reply back from the server.
      *
      * <p>
      * This property is used on the client-side for
      * outbound messages, so that a pipeline
      * can communicate to the terminal (or intermediate) {@link Tube}s
      * about this knowledge.
      *
      * <p>
      * This property <b>MUST NOT</b> be used by 2-way transports
      * that have the transport back channel. Those transports
      * must always check a reply coming through the transport back
      * channel regardless of this value, and act accordingly.
      * (This is because the expectation of the client and
      * that of the server can be different, for example because
      * of a bug in user's configuration.)
      *
      * <p>
      * This property is for one-way transports, and more
      * specifically for the coordinator that correlates sent requests
      * and incoming replies, to decide whether to block
      * until a response is received.
      *
      * <p>
      * Also note that this property is related to
      * {@link WSDLOperation#isOneWay()} but not the same thing.
      * In fact in general, they are completely orthogonal.
      *
      * For example, the calling application can choose to invoke
      * {@link Dispatch#invoke(Object)} or {@link Dispatch#invokeOneWay(Object)}
      * with an operation (which determines the value of this property),
      * regardless of whether WSDL actually says it's one way or not.
      * So these two booleans can take any combinations.
      *
      *
      * <p>
      * When this property is {@link Boolean#FALSE}, it means that
      * the pipeline does not expect a reply from a server (and therefore
      * the correlator should not block for a reply message
      * -- if such a reply does arrive, it can be just ignored.)
      *
      * <p>
      * When this property is {@link Boolean#TRUE}, it means that
      * the pipeline expects a reply from a server (and therefore
      * the correlator should block to see if a reply message is received,
      *
      * <p>
      * This property is always set to {@link Boolean#TRUE} or
      * {@link Boolean#FALSE} when used on the request message
      * on the client side.
      * No other {@link Boolean} instances are allowed.
      * <p>
      *
      * In all other situations, this property is null.
      *
      */
     @Property(BindingProviderProperties.ONE_WAY_OPERATION)
     public Boolean expectReply;
     /**
      * This property will be removed in a near future.
      *
      * <p>
      * A part of what this flag represented moved to
      * {@link #expectReply} and the other part was moved
      * to {@link Message#isOneWay(WSDLPort)}. Please update
      * your code soon, or risk breaking your build!!
      */
     @Deprecated
     public Boolean isOneWay;
     /**
      * Indicates whether is invoking a synchronous pattern. If true, no
      * async client programming model (e.g. AsyncResponse or AsyncHandler)
      * were used to make the request that created this packet.
      */
     public Boolean isSynchronousMEP;
     /**
      * Indicates whether a non-null AsyncHandler was given at the point of
      * making the request that created this packet. This flag can be used
      * by Tube implementations to decide how to react when isSynchronousMEP
      * is false. If true, the client gave a non-null AsyncHandler instance
      * at the point of request, and will be expecting a response on that
      * handler when this request has been processed.
      */
     public Boolean nonNullAsyncHandlerGiven;
     /**
      * USE-CASE:
      * WS-AT is enabled, but there is no WSDL available.
      * If Packet.isRequestReplyMEP() is Boolean.TRUE then WS-AT should
      * add the TX context.
      *
      * This value is exposed to users via facades at higher abstraction layers.
      * The user should NEVER use Packet directly.
      * This value should ONLY be set by users.
      */
     private Boolean isRequestReplyMEP;
     public Boolean isRequestReplyMEP() { return isRequestReplyMEP; }
     public void setRequestReplyMEP(final Boolean x) { isRequestReplyMEP = x; }
     /**
      * Lazily created set of handler-scope property names.
      *
      * <p>
      * We expect that this is only used when handlers are present
      * and they explicitly set some handler-scope values.
      *
      * @see #getHandlerScopePropertyNames(boolean)
      */
     private Set<String> handlerScopePropertyNames;
     /**
      * Bag to capture properties that are available for the whole
      * message invocation (namely on both requests and responses.)
      *
      * <p>
      * These properties are copied from a request to a response.
      * This is where we keep properties that are set by handlers.
      *
      * <p>
      * See <a href="#properties">class javadoc</a> for more discussion.
      *
      * @see #getHandlerScopePropertyNames(boolean)
      */
     public final Map<String, Object> invocationProperties;
     /**
      * Gets a {@link Set} that stores handler-scope properties.
      *
      * <p>
      * These properties will not be exposed to the response context.
      * Consequently, if a {@link Tube} wishes to hide a property
      * to {@link ResponseContext}, it needs to add the property name
      * to this set.
      *
      * @param readOnly
      *      Return true if the caller only intends to read the value of this set.
      *      Internally, the {@link Set} is allocated lazily, and this flag helps
      *      optimizing the strategy.
      *
      * @return
      *      always non-null, possibly empty set that stores property names.
      */
     public final Set<String> getHandlerScopePropertyNames(boolean readOnly) {
         Set<String> o = this.handlerScopePropertyNames;
         if (o == null) {
             if (readOnly) {
                 return Collections.emptySet();
             }
             o = new HashSet<String>();
             this.handlerScopePropertyNames = o;
         }
         return o;
     }
     /**
      * This method no longer works.
      *
      * @deprecated
      *      Use {@link #getHandlerScopePropertyNames(boolean)}.
      *      To be removed once Tango components are updated.
      */
     public final Set<String> getApplicationScopePropertyNames(boolean readOnly) {
         assert false;
         return new HashSet<String>();
     }
     /**
      * Creates a response {@link Packet} from a request packet ({@code this}).
      *
      * <p>
      * When a {@link Packet} for a reply is created, some properties need to be
      * copied over from a request to a response, and this method handles it correctly.
      *
      * @deprecated
      *      Use createClientResponse(Message) for client side and
      *      createServerResponse(Message, String) for server side response
      *      creation.
      *
      * @param msg
      *      The {@link Message} that represents a reply. Can be null.
      */
     @Deprecated
     public Packet createResponse(Message msg) {
         Packet response = new Packet(this);
         response.setMessage(msg);
         return response;
     }
     /**
      * Creates a response {@link Packet} from a request packet ({@code this}).
      *
      * <p>
      * When a {@link Packet} for a reply is created, some properties need to be
      * copied over from a request to a response, and this method handles it correctly.
      *
      * @param msg
      *      The {@link Message} that represents a reply. Can be null.
      */
     public Packet createClientResponse(Message msg) {
         Packet response = new Packet(this);
         response.setMessage(msg);
         finishCreateRelateClientResponse(response);
         return response;
     }
     /**
      * For use cases that start with an existing Packet.
      */
     public Packet relateClientResponse(final Packet response) {
         response.relatePackets(this, true);
         finishCreateRelateClientResponse(response);
         return response;
     }
     private void finishCreateRelateClientResponse(final Packet response) {
         response.soapAction = null; // de-initializing
         response.setState(State.ClientResponse);
     }
     /**
      * Creates a server-side response {@link Packet} from a request
      * packet ({@code this}). If WS-Addressing is enabled, a default Action
      * Message Addressing Property is obtained using <code>wsdlPort</code> {@link WSDLPort}
      * and <code>binding</code> {@link WSBinding}.
      * <p><p>
      * This method should be called to create application response messages
      * since they are associated with a {@link WSBinding} and {@link WSDLPort}.
      * For creating protocol messages that require a non-default Action, use
      * {@link #createServerResponse(Message, com.sun.xml.internal.ws.api.addressing.AddressingVersion, com.sun.xml.internal.ws.api.SOAPVersion, String)}.
      *
      * @param responseMessage The {@link Message} that represents a reply. Can be null.
      * @param wsdlPort The response WSDL port.
      * @param binding The response Binding. Cannot be null.
      * @return response packet
      */
     public Packet createServerResponse(@Nullable Message responseMessage, @Nullable WSDLPort wsdlPort, @Nullable SEIModel seiModel, @NotNull WSBinding binding) {
         Packet r = createClientResponse(responseMessage);
         return relateServerResponse(r, wsdlPort, seiModel, binding);
     }
     /**
      * Copy all properties from ({@code this}) packet into a input {@link Packet}
      * @param response packet
      */
     public void copyPropertiesTo(@Nullable Packet response){
         relatePackets(response, false);
     }
     /**
      * A common method to make members related between input packet and this packet
      *
      * @param packet
      * @param isCopy 'true' means copying all properties from input packet;
      *               'false' means copying all properties from this packet to input packet.
      */
     private void relatePackets(@Nullable Packet packet, boolean isCopy)
     {
         Packet request;
             Packet response;
         if (!isCopy) { //is relate
           request = this;
           response = packet;
           // processing specific properties
           response.soapAction = null;
           response.invocationProperties.putAll(request.invocationProperties);
           if (this.getState().equals(State.ServerRequest)) {
               response.setState(State.ServerResponse);
           }
         } else { //is copy constructor
           request = packet;
           response = this;
           // processing specific properties
           response.soapAction = request.soapAction;
           response.setState(request.getState());
         }
         request.copySatelliteInto(response);
         response.isAdapterDeliversNonAnonymousResponse = request.isAdapterDeliversNonAnonymousResponse;
         response.handlerConfig = request.handlerConfig;
         response.handlerScopePropertyNames = request.handlerScopePropertyNames;
         response.contentNegotiation = request.contentNegotiation;
         response.wasTransportSecure = request.wasTransportSecure;
         response.transportBackChannel = request.transportBackChannel;
         response.endpointAddress = request.endpointAddress;
         response.wsdlOperation = request.wsdlOperation;
         response.wsdlOperationMapping = request.wsdlOperationMapping;
         response.acceptableMimeTypes = request.acceptableMimeTypes;
         response.endpoint = request.endpoint;
         response.proxy = request.proxy;
         response.webServiceContextDelegate = request.webServiceContextDelegate;
         response.expectReply = request.expectReply;
         response.component = request.component;
         response.mtomAcceptable = request.mtomAcceptable;
         response.mtomRequest = request.mtomRequest;
         // copy other properties that need to be copied. is there any?
     }
     public Packet relateServerResponse(@Nullable Packet r, @Nullable WSDLPort wsdlPort, @Nullable SEIModel seiModel, @NotNull WSBinding binding) {
         relatePackets(r, false);
         r.setState(State.ServerResponse);
         AddressingVersion av = binding.getAddressingVersion();
         // populate WS-A headers only if WS-A is enabled
         if (av == null) {
             return r;
         }
         if (getMessage() == null) {
             return r;
         }
         //populate WS-A headers only if the request has addressing headers
         String inputAction = AddressingUtils.getAction(getMessage().getHeaders(), av, binding.getSOAPVersion());
         if (inputAction == null) {
             return r;
         }
         // if one-way, then dont populate any WS-A headers
         if (r.getMessage() == null || (wsdlPort != null && getMessage().isOneWay(wsdlPort))) {
             return r;
         }
         // otherwise populate WS-Addressing headers
         populateAddressingHeaders(binding, r, wsdlPort, seiModel);
         return r;
     }
     /**
      * Creates a server-side response {@link Packet} from a request
      * packet ({@code this}). If WS-Addressing is enabled, <code>action</code>
      * is used as Action Message Addressing Property.
      * <p><p>
      * This method should be called only for creating protocol response messages
      * that require a particular value of Action since they are not associated
      * with a {@link WSBinding} and {@link WSDLPort} but do know the {@link AddressingVersion}
      * and {@link SOAPVersion}.
      *
      * @param responseMessage The {@link Message} that represents a reply. Can be null.
      * @param addressingVersion The WS-Addressing version of the response message.
      * @param soapVersion The SOAP version of the response message.
      * @param action The response Action Message Addressing Property value.
      * @return response packet
      */
     public Packet createServerResponse(@Nullable Message responseMessage, @NotNull AddressingVersion addressingVersion, @NotNull SOAPVersion soapVersion, @NotNull String action) {
         Packet responsePacket = createClientResponse(responseMessage);
         responsePacket.setState(State.ServerResponse);
         // populate WS-A headers only if WS-A is enabled
         if (addressingVersion == null) {
             return responsePacket;
         }
         //populate WS-A headers only if the request has addressing headers
         String inputAction = AddressingUtils.getAction(this.getMessage().getHeaders(), addressingVersion, soapVersion);
         if (inputAction == null) {
             return responsePacket;
         }
         populateAddressingHeaders(responsePacket, addressingVersion, soapVersion, action, false);
         return responsePacket;
     }
     /**
      * Overwrites the {@link Message} of the response packet ({@code this}) by the given {@link Message}.
      * Unlike {@link #setMessage(Message)}, fill in the addressing headers correctly, and this process
      * requires the access to the request packet.
      *
      * <p>
      * This method is useful when the caller needs to swap a response message completely to a new one.
      *
      * @see #createServerResponse(Message, AddressingVersion, SOAPVersion, String)
      */
     public void setResponseMessage(@NotNull Packet request, @Nullable Message responseMessage, @NotNull AddressingVersion addressingVersion, @NotNull SOAPVersion soapVersion, @NotNull String action) {
         Packet temp = request.createServerResponse(responseMessage, addressingVersion, soapVersion, action);
         setMessage(temp.getMessage());
     }
     private void populateAddressingHeaders(Packet responsePacket, AddressingVersion av, SOAPVersion sv, String action, boolean mustUnderstand) {
         // populate WS-A headers only if WS-A is enabled
         if (av == null) return;
         // if one-way, then dont populate any WS-A headers
         if (responsePacket.getMessage() == null)
             return;
         MessageHeaders hl = responsePacket.getMessage().getHeaders();
         WsaPropertyBag wpb = getSatellite(WsaPropertyBag.class);
         Message msg = getMessage();
         // wsa:To
         WSEndpointReference replyTo = null;
         Header replyToFromRequestMsg = AddressingUtils.getFirstHeader(msg.getHeaders(), av.replyToTag, true, sv);
         Header replyToFromResponseMsg = hl.get(av.toTag, false);
         boolean replaceToTag = true;
         try{
             if (replyToFromRequestMsg != null){
                 replyTo = replyToFromRequestMsg.readAsEPR(av);
             }
             if (replyToFromResponseMsg != null && replyTo == null) {
                 replaceToTag = false;
             }
         } catch (XMLStreamException e) {
             throw new WebServiceException(AddressingMessages.REPLY_TO_CANNOT_PARSE(), e);
         }
         if (replyTo == null) {
               replyTo = AddressingUtils.getReplyTo(msg.getHeaders(), av, sv);
         }
         // wsa:Action, add if the message doesn't already contain it,
         // generally true for SEI case where there is SEIModel or WSDLModel
         //           false for Provider with no wsdl, Expects User to set the coresponding header on the Message.
         if (AddressingUtils.getAction(responsePacket.getMessage().getHeaders(), av, sv) == null) {
             //wsa:Action header is not set in the message, so use the wsa:Action  passed as the parameter.
             hl.add(new StringHeader(av.actionTag, action, sv, mustUnderstand));
         }
         // wsa:MessageID
         if (responsePacket.getMessage().getHeaders().get(av.messageIDTag, false) == null) {
             // if header doesn't exist, method getID creates a new random id
             String newID = Message.generateMessageID();
             hl.add(new StringHeader(av.messageIDTag, newID));
         }
         // wsa:RelatesTo
         String mid = null;
         if (wpb != null) {
             mid = wpb.getMessageID();
         }
         if (mid == null) {
             mid = AddressingUtils.getMessageID(msg.getHeaders(), av, sv);
         }
         if (mid != null) {
             hl.addOrReplace(new RelatesToHeader(av.relatesToTag, mid));
         }
         // populate reference parameters
         WSEndpointReference refpEPR = null;
         if (responsePacket.getMessage().isFault()) {
             // choose FaultTo
             if (wpb != null) {
                 refpEPR = wpb.getFaultToFromRequest();
             }
             if (refpEPR == null) {
                 refpEPR = AddressingUtils.getFaultTo(msg.getHeaders(), av, sv);
             }
             // if FaultTo is null, then use ReplyTo
             if (refpEPR == null) {
                 refpEPR = replyTo;
             }
         } else {
             // choose ReplyTo
             refpEPR = replyTo;
         }
         if (replaceToTag && refpEPR != null) {
             hl.addOrReplace(new StringHeader(av.toTag, refpEPR.getAddress()));
             refpEPR.addReferenceParametersToList(hl);
         }
     }
     private void populateAddressingHeaders(WSBinding binding, Packet responsePacket, WSDLPort wsdlPort, SEIModel seiModel) {
         AddressingVersion addressingVersion = binding.getAddressingVersion();
         if (addressingVersion == null) {
             return;
         }
         WsaTubeHelper wsaHelper = addressingVersion.getWsaHelper(wsdlPort, seiModel, binding);
         String action = responsePacket.getMessage().isFault() ?
                 wsaHelper.getFaultAction(this, responsePacket) :
                 wsaHelper.getOutputAction(this);
         if (action == null) {
             LOGGER.info("WSA headers are not added as value for wsa:Action cannot be resolved for this message");
             return;
         }
         populateAddressingHeaders(responsePacket, addressingVersion, binding.getSOAPVersion(), action, AddressingVersion.isRequired(binding));
     }
     public String toShortString() {
       return super.toString();
     }
     // For use only in a debugger
     @Override
     public String toString() {
       StringBuilder buf = new StringBuilder();
       buf.append(super.toString());
       String content;
         try {
             Message msg = getMessage();
         if (msg != null) {
                         ByteArrayOutputStream baos = new ByteArrayOutputStream();
                         XMLStreamWriter xmlWriter = XMLStreamWriterFactory.create(baos, "UTF-8");
                         msg.copy().writeTo(xmlWriter);
                         xmlWriter.flush();
                         xmlWriter.close();
                         baos.flush();
                         XMLStreamWriterFactory.recycle(xmlWriter);
                         byte[] bytes = baos.toByteArray();
                         //message = Messages.create(XMLStreamReaderFactory.create(null, new ByteArrayInputStream(bytes), "UTF-8", true));
                         content = new String(bytes, "UTF-8");
                 } else {
                     content = "<none>";
         }
         } catch (Throwable t) {
                 throw new WebServiceException(t);
         }
       buf.append(" Content: ").append(content);
       return buf.toString();
     }
     // completes TypedMap
     private static final PropertyMap model;
     static {
         model = parse(Packet.class);
     }
     @Override
     protected PropertyMap getPropertyMap() {
         return model;
     }
     public Map<String, Object> asMapIncludingInvocationProperties() {
         final Map<String, Object> asMap = asMap();
         return new AbstractMap<String, Object>() {
             @Override
             public Object get(Object key) {
                 Object o = asMap.get(key);
                 if (o != null)
                     return o;
                 return invocationProperties.get(key);
             }
             @Override
             public int size() {
                 return asMap.size() + invocationProperties.size();
             }
             @Override
             public boolean containsKey(Object key) {
                 if (asMap.containsKey(key))
                     return true;
                 return invocationProperties.containsKey(key);
             }
             @Override
             public Set<Entry<String, Object>> entrySet() {
                 final Set<Entry<String, Object>> asMapEntries = asMap.entrySet();
                 final Set<Entry<String, Object>> ipEntries = invocationProperties.entrySet();
                 return new AbstractSet<Entry<String, Object>>() {
                     @Override
                     public Iterator<Entry<String, Object>> iterator() {
                         final Iterator<Entry<String, Object>> asMapIt = asMapEntries.iterator();
                         final Iterator<Entry<String, Object>> ipIt = ipEntries.iterator();
                         return new Iterator<Entry<String, Object>>() {
                             @Override
                             public boolean hasNext() {
                                 return asMapIt.hasNext() || ipIt.hasNext();
                             }
                             @Override
                             public java.util.Map.Entry<String, Object> next() {
                                 if (asMapIt.hasNext())
                                     return asMapIt.next();
                                 return ipIt.next();
                             }
                             @Override
                             public void remove() {
                                 throw new UnsupportedOperationException();
                             }
                         };
                     }
                     @Override
                     public int size() {
                         return asMap.size() + invocationProperties.size();
                     }
                 };
             }
             @Override
             public Object put(String key, Object value) {
                 if (supports(key))
                     return asMap.put(key, value);
                 return invocationProperties.put(key, value);
             }
             @Override
             public void clear() {
                 asMap.clear();
                 invocationProperties.clear();
             }
             @Override
             public Object remove(Object key) {
                 if (supports(key))
                     return asMap.remove(key);
                 return invocationProperties.remove(key);
             }
         };
     }
     private static final Logger LOGGER = Logger.getLogger(Packet.class.getName());
     @Override
     public SOAPMessage getSOAPMessage() throws SOAPException {
         return getAsSOAPMessage();
     }
     //TODO replace the message to a SAAJMEssage issue - JRFSAAJMessage or SAAJMessage?
     @Override
     public SOAPMessage getAsSOAPMessage() throws SOAPException {
         Message msg = this.getMessage();
         if (msg == null)
             return null;
         if (msg instanceof MessageWritable)
             ((MessageWritable) msg).setMTOMConfiguration(mtomFeature);
         return msg.readAsSOAPMessage(this, this.getState().isInbound());
     }
     public
     Codec codec = null;
     public Codec getCodec() {
         if (codec != null) {
             return codec;
         }
         if (endpoint != null) {
             codec = endpoint.createCodec();
         }
         WSBinding wsb = getBinding();
         if (wsb != null) {
             codec = wsb.getBindingId().createEncoder(wsb);
         }
         return codec;
     }
     @Override
     public com.oracle.webservices.internal.api.message.ContentType writeTo( OutputStream out ) throws IOException {
         Message msg = getInternalMessage();
         if (msg instanceof MessageWritable) {
             ((MessageWritable) msg).setMTOMConfiguration(mtomFeature);
             return ((MessageWritable)msg).writeTo(out);
         }
         return getCodec().encode(this, out);
     }
     public com.oracle.webservices.internal.api.message.ContentType writeTo( WritableByteChannel buffer ) {
         return getCodec().encode(this, buffer);
     }
     private ContentType contentType;
     /**
      * 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 mtomRequest;
     /**
      * 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 mtomAcceptable;
     private MTOMFeature mtomFeature;
     public Boolean getMtomRequest() {
         return mtomRequest;
     }
     public void setMtomRequest(Boolean mtomRequest) {
         this.mtomRequest = mtomRequest;
     }
     public Boolean getMtomAcceptable() {
         return mtomAcceptable;
     }
     Boolean checkMtomAcceptable;
     public void checkMtomAcceptable() {
         if (checkMtomAcceptable == null) {
             if (acceptableMimeTypes == null || isFastInfosetDisabled) {
                 checkMtomAcceptable = false;
             } else {
                 checkMtomAcceptable = (acceptableMimeTypes.indexOf(MtomCodec.XOP_XML_MIME_TYPE) != -1);
 //                StringTokenizer st = new StringTokenizer(acceptableMimeTypes, ",");
 //                while (st.hasMoreTokens()) {
 //                    final String token = st.nextToken().trim();
 //                    if (token.toLowerCase().contains(MtomCodec.XOP_XML_MIME_TYPE)) {
 //                        mtomAcceptable = true;
 //                    }
 //                }
 //                if (mtomAcceptable == null) mtomAcceptable = false;
             }
         }
         mtomAcceptable = checkMtomAcceptable;
     }
     private Boolean fastInfosetAcceptable;
     public Boolean getFastInfosetAcceptable(String fiMimeType) {
         if (fastInfosetAcceptable == null) {
             if (acceptableMimeTypes == null || isFastInfosetDisabled) {
                 fastInfosetAcceptable = false;
             } else {
                 fastInfosetAcceptable = (acceptableMimeTypes.indexOf(fiMimeType) != -1);
             }
 //        if (accept == null || isFastInfosetDisabled) return false;
 //
 //        StringTokenizer st = new StringTokenizer(accept, ",");
 //        while (st.hasMoreTokens()) {
 //            final String token = st.nextToken().trim();
 //            if (token.equalsIgnoreCase(fiMimeType)) {
 //                return true;
 //            }
 //        }
 //        return false;
         }
         return fastInfosetAcceptable;
     }
     public void setMtomFeature(MTOMFeature mtomFeature) {
         this.mtomFeature = mtomFeature;
     }
     public MTOMFeature getMtomFeature() {
         //If we have a binding, use that in preference to an explicitly
         //set MTOMFeature
         WSBinding binding = getBinding();
         if (binding != null) {
             return binding.getFeature(MTOMFeature.class);
         }
         return mtomFeature;
     }
     @Override
     public com.oracle.webservices.internal.api.message.ContentType getContentType() {
         if (contentType == null) {
             contentType = getInternalContentType();
         }
         if (contentType == null) {
             contentType = getCodec().getStaticContentType(this);
         }
         if (contentType == null) {
             //TODO write to buffer
         }
         return contentType;
     }
     public ContentType getInternalContentType() {
         Message msg = getInternalMessage();
         if (msg instanceof MessageWritable) {
             return ((MessageWritable)msg).getContentType();
         }
         return contentType;
     }
     public void setContentType(ContentType contentType) {
         this.contentType = contentType;
     }
     public enum Status {
         Request, Response, Unknown;
         public boolean isRequest()  { return Request.equals(this); }
         public boolean isResponse() { return Response.equals(this); }
     }
     public enum State {
         ServerRequest(true), ClientRequest(false), ServerResponse(false), ClientResponse(true);
         private boolean inbound;
         State(boolean inbound) {
             this.inbound = inbound;
         }
         public boolean isInbound() {
             return inbound;
         }
     }
 //    private Status status = Status.Unknown;
     //Default state is ServerRequest - some custom adapters may not set the value of state
     //upon server request - all other code paths should set it
     private State state = State.ServerRequest;
 //    public Status getStatus() { return status; }
     public State getState() { return state; }
     public void setState(State state) { this.state = state; }
     public boolean shouldUseMtom() {
         if (getState().isInbound()) {
             return isMtomContentType();
         } else {
             return shouldUseMtomOutbound();
         }
     }
     private boolean shouldUseMtomOutbound() {
         //Use the getter to make sure all the logic is executed correctly
         MTOMFeature myMtomFeature = getMtomFeature();
         if(myMtomFeature != null && myMtomFeature.isEnabled()) {
             //On client, always use XOP encoding if MTOM is enabled
             //On Server, mtomAcceptable and mtomRequest will be set - use XOP encoding
             //if either request is XOP encoded (mtomRequest) or
             //client accepts XOP encoding (mtomAcceptable)
             if (getMtomAcceptable() == null && getMtomRequest() == null) {
                 return true;
             } else {
                 if (getMtomAcceptable() != null &&  getMtomAcceptable() && getState().equals(State.ServerResponse)) {
                     return true;
                 }
                 if (getMtomRequest() != null && getMtomRequest() && getState().equals(State.ServerResponse)) {
                     return true;
                 }
             }
         }
         return false;
     }
     private boolean isMtomContentType() {
         return (getInternalContentType() != null) &&
         (getInternalContentType().getContentType().contains("application/xop+xml"));
     }
     /**
      * @deprecated
      */
     public void addSatellite(@NotNull com.sun.xml.internal.ws.api.PropertySet satellite) {
         super.addSatellite(satellite);
     }
     /**
      * @deprecated
      */
     public void addSatellite(@NotNull Class keyClass, @NotNull com.sun.xml.internal.ws.api.PropertySet satellite) {
         super.addSatellite(keyClass, satellite);
     }
     /**
      * @deprecated
      */
     public void copySatelliteInto(@NotNull com.sun.xml.internal.ws.api.DistributedPropertySet r) {
         super.copySatelliteInto(r);
     }
     /**
      * @deprecated
      */
     public void removeSatellite(com.sun.xml.internal.ws.api.PropertySet satellite) {
         super.removeSatellite(satellite);
     }
     /**
      * This is propogated from SOAPBindingCodec and will affect isMtomAcceptable and isFastInfosetAcceptable
      */
     private boolean isFastInfosetDisabled;
     public void setFastInfosetDisabled(boolean b) {
         isFastInfosetDisabled = b;
     }
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/com/sun/xml/internal/ws/api/message/Packet.java@8f2986ff0235 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/message/Packet.java