| /* |
| * Copyright 2001-2004 The Apache Software Foundation. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.axis; |
| |
| import org.apache.axis.attachments.Attachments; |
| import org.apache.axis.components.logger.LogFactory; |
| import org.apache.axis.message.SOAPEnvelope; |
| import org.apache.axis.message.MimeHeaders; |
| import org.apache.axis.soap.SOAPConstants; |
| import org.apache.axis.transport.http.HTTPConstants; |
| import org.apache.axis.utils.ClassUtils; |
| import org.apache.axis.utils.Messages; |
| import org.apache.axis.utils.XMLUtils; |
| import org.apache.commons.logging.Log; |
| |
| import javax.xml.soap.AttachmentPart; |
| import javax.xml.soap.SOAPException; |
| import javax.xml.soap.SOAPBody; |
| import javax.xml.soap.SOAPHeader; |
| import javax.xml.soap.SOAPMessage; |
| |
| import java.io.IOException; |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.Iterator; |
| import java.util.Collections; |
| |
| /** |
| * A complete SOAP (and/or XML-RPC, eventually) message. |
| * Includes both the root part (as a SOAPPart), and zero or |
| * more MIME attachments (as AttachmentParts). |
| * <p> |
| * Eventually should be refactored to generalize SOAPPart |
| * for multiple protocols (XML-RPC?). |
| * |
| * @author Rob Jellinghaus (robj@unrealities.com) |
| * @author Doug Davis (dug@us.ibm.com) |
| * @author Glen Daniels (gdaniels@allaire.com) |
| * @author Rick Rineholt |
| * @author Heejune Ahn (cityboy@tmax.co.kr) |
| */ |
| public class Message extends javax.xml.soap.SOAPMessage |
| implements java.io.Serializable { |
| |
| /** |
| * The <code>Log</code> that this class uses for logging all messages. |
| */ |
| protected static Log log = |
| LogFactory.getLog(Message.class.getName()); |
| |
| /** Message is a request. */ |
| public static final String REQUEST = "request"; |
| |
| /** Message is a a response. */ |
| public static final String RESPONSE = "response"; |
| |
| /** MIME parts defined for messages. */ |
| public static final String MIME_MULTIPART_RELATED = "multipart/related"; |
| |
| /** DIME parts defined for messages. */ |
| public static final String MIME_APPLICATION_DIME = "application/dime"; |
| |
| /** Content Type for MTOM/XOP */ |
| public static final String CONTENT_TYPE_MTOM = "application/xop+xml"; |
| |
| /** Default Attachments Implementation class. */ |
| public static final String DEFAULT_ATTACHMNET_IMPL="org.apache.axis.attachments.AttachmentsImpl"; |
| |
| /** Current Attachment implementation. */ |
| private static String mAttachmentsImplClassName=DEFAULT_ATTACHMNET_IMPL; |
| |
| /** Look at the input stream to find the headers to decide the mime type. */ |
| public static final String MIME_UNKNOWN = " "; |
| |
| // fixme: is this constrained to two values - request/response (e.g. |
| // REQUEST and RESPONSE)? If so, this needs documenting in the get/set |
| // methods and/or converting into a type-safe e-num. Potentially get/set |
| // methods should check these values & throw IllegalArgumentException |
| /** |
| * The messageType indicates whether this is request or response. |
| */ |
| private String messageType; |
| |
| /** |
| * This Message's SOAPPart. Will always be here. |
| */ |
| private SOAPPart mSOAPPart; |
| |
| /** |
| * This Message's Attachments object, which manages the attachments |
| * contained in this Message. |
| */ |
| private Attachments mAttachments = null; |
| |
| private MimeHeaders headers; |
| |
| private boolean saveRequired = true; |
| |
| /** |
| * Returns the name of the class prividing Attachment Implementation. |
| * |
| * @return class name |
| */ |
| public static String getAttachmentImplClassName(){ |
| return mAttachmentsImplClassName; |
| } |
| |
| private MessageContext msgContext; |
| |
| /** |
| * Get the message type. |
| * |
| * @return the message type <code>String</code> |
| */ |
| public String getMessageType() { |
| return messageType; |
| } |
| |
| /** |
| * Set the message type. |
| * |
| * @param messageType the message type <code>String</code> |
| */ |
| public void setMessageType(String messageType) { |
| this.messageType = messageType; |
| } |
| |
| /** |
| * Get the context associated with this message. |
| * |
| * @return the message context for this message |
| */ |
| public MessageContext getMessageContext() { |
| return msgContext; |
| } |
| |
| /** |
| * Set the context associated with this message. |
| * |
| * @param msgContext the message context for this message |
| */ |
| public void setMessageContext(MessageContext msgContext) { |
| this.msgContext = msgContext; |
| } |
| |
| /** |
| * Construct a Message, using the provided initialContents as the |
| * contents of the Message's SOAPPart. |
| * <p> |
| * Eventually, genericize this to |
| * return the RootPart instead, which will have some kind of |
| * EnvelopeFactory to enable support for things other than SOAP. |
| * But that all will come later, with lots of additional refactoring. |
| * |
| * @param initialContents may be String, byte[], InputStream, SOAPEnvelope, |
| * or AxisFault. |
| * @param bodyInStream is true if initialContents is an InputStream |
| * containing just the SOAP body (no SOAP-ENV). |
| */ |
| public Message(Object initialContents, boolean bodyInStream) { |
| setup(initialContents, bodyInStream, null, null, null); |
| } |
| |
| /** |
| * Construct a Message, using the provided initialContents as the |
| * contents of the Message's SOAPPart. |
| * <p> |
| * Eventually, genericize this to |
| * return the RootPart instead, which will have some kind of |
| * EnvelopeFactory to enable support for things other than SOAP. |
| * But that all will come later, with lots of additional refactoring. |
| * |
| * @param initialContents may be String, byte[], InputStream, SOAPEnvelope, |
| * or AxisFault. |
| * @param bodyInStream is true if initialContents is an InputStream |
| * containing just the SOAP body (no SOAP-ENV). |
| * @param headers Mime Headers. |
| */ |
| public Message(Object initialContents, boolean bodyInStream, javax.xml.soap.MimeHeaders headers) { |
| setup(initialContents, bodyInStream, null, null, headers); |
| } |
| |
| /** |
| * Construct a Message, using the provided initialContents as the |
| * contents of the Message's SOAPPart. |
| * <p> |
| * Eventually, genericize this to |
| * return the RootPart instead, which will have some kind of |
| * EnvelopeFactory to enable support for things other than SOAP. |
| * But that all will come later, with lots of additional refactoring. |
| * |
| * @param initialContents may be String, byte[], InputStream, SOAPEnvelope, |
| * or AxisFault. |
| * @param headers Mime Headers. |
| */ |
| public Message(Object initialContents, MimeHeaders headers) { |
| setup(initialContents, true, null, null, headers); |
| } |
| |
| /** |
| * Construct a Message, using the provided initialContents as the |
| * contents of the Message's SOAPPart. |
| * <p> |
| * Eventually, genericize this to |
| * return the RootPart instead, which will have some kind of |
| * EnvelopeFactory to enable support for things other than SOAP. |
| * But that all will come later, with lots of additional refactoring. |
| * |
| * @param initialContents may be String, byte[], InputStream, SOAPEnvelope, |
| * or AxisFault |
| * @param bodyInStream is true if initialContents is an InputStream |
| * containing just the SOAP body (no SOAP-ENV) |
| * @param contentType this if the contentType has been already determined |
| * (as in the case of servlets) |
| * @param contentLocation the location of the content |
| */ |
| public Message(Object initialContents, |
| boolean bodyInStream, |
| String contentType, |
| String contentLocation) { |
| setup(initialContents, bodyInStream, contentType, contentLocation, null); |
| } |
| |
| /** |
| * Construct a Message. An overload of Message(Object, boolean), |
| * defaulting bodyInStream to false. |
| * |
| * @param initialContents may be String, byte[], InputStream, SOAPEnvelope, |
| * or AxisFault |
| */ |
| public Message(Object initialContents) { |
| setup(initialContents, false, null, null, null); |
| } |
| |
| private static Class attachImpl = null; |
| |
| //aviod testing and possibly failing everytime. |
| private static boolean checkForAttachmentSupport = true; |
| |
| private static boolean attachmentSupportEnabled = false; |
| |
| private static synchronized boolean isAttachmentSupportEnabled(MessageContext mc) { |
| if (checkForAttachmentSupport) { |
| //aviod testing and possibly failing everytime. |
| checkForAttachmentSupport = false; |
| try { |
| // Get the default setting from AxisProperties |
| String attachImpName = AxisProperties.getProperty(AxisEngine.PROP_ATTACHMENT_IMPLEMENTATION, |
| AxisEngine.DEFAULT_ATTACHMENT_IMPL); |
| // override the default with any changes specified in the engine configuration |
| if (null != mc) { |
| AxisEngine ae = mc.getAxisEngine(); |
| if (null != ae) { |
| attachImpName = (String) ae.getOption( |
| AxisEngine.PROP_ATTACHMENT_IMPLEMENTATION); |
| } |
| } |
| |
| /** |
| * Attempt to resolve class name, verify that these are present... |
| */ |
| ClassUtils.forName("javax.activation.DataHandler"); |
| ClassUtils.forName("javax.mail.internet.MimeMultipart"); |
| |
| attachImpl = ClassUtils.forName(attachImpName); |
| |
| attachmentSupportEnabled = true; |
| } catch (ClassNotFoundException ex) { |
| // no support for it, leave mAttachments null. |
| } catch (java.lang.NoClassDefFoundError ex) { |
| // no support for it, leave mAttachments null. |
| } catch (java.lang.SecurityException ex) { |
| // no support for it, leave mAttachments null. |
| } |
| log.debug(Messages.getMessage("attachEnabled") + " " + |
| attachmentSupportEnabled); |
| } |
| return attachmentSupportEnabled; |
| } |
| |
| /** |
| * Do the work of construction. |
| * |
| * @param initialContents may be String, byte[], InputStream, SOAPEnvelope, |
| * or AxisFault |
| * @param bodyInStream is true if initialContents is an InputStream |
| * containing just the SOAP body (no SOAP-ENV) |
| * @param contentType this if the contentType has been already determined |
| * (as in the case of servlets) |
| * @param contentLocation the location of the content |
| * @param mimeHeaders mime headers for attachments |
| */ |
| private void setup(Object initialContents, boolean bodyInStream, |
| String contentType, String contentLocation, |
| javax.xml.soap.MimeHeaders mimeHeaders) { |
| |
| if(contentType == null && mimeHeaders != null) { |
| String contentTypes[] = mimeHeaders.getHeader("Content-Type"); |
| contentType = (contentTypes != null)? contentTypes[0] : null; |
| } |
| if(contentLocation == null && mimeHeaders != null) { |
| String contentLocations[] = mimeHeaders.getHeader("Content-Location"); |
| contentLocation = (contentLocations != null)? contentLocations[0] : null; |
| } |
| if (contentType != null) { |
| int delimiterIndex = contentType.lastIndexOf("charset"); |
| if (delimiterIndex > 0) { |
| String charsetPart = contentType.substring(delimiterIndex); |
| int delimiterIndex2 = charsetPart.indexOf(';'); |
| if(delimiterIndex2 != -1){ |
| charsetPart = charsetPart.substring(0, delimiterIndex2); |
| } |
| int charsetIndex = charsetPart.indexOf('='); |
| String charset = charsetPart.substring(charsetIndex + 1).trim(); |
| if ((charset.startsWith("\"") || charset.startsWith("\'"))) { |
| charset = charset.substring(1, charset.length()); |
| } |
| if ((charset.endsWith("\"") || charset.endsWith("\'"))) { |
| charset = charset.substring(0, charset.length()-1); |
| } |
| try { |
| setProperty(SOAPMessage.CHARACTER_SET_ENCODING, charset); |
| } catch (SOAPException e) { |
| } |
| } |
| } |
| // Try to construct an AttachmentsImpl object for attachment |
| // functionality. |
| // If there is no org.apache.axis.attachments.AttachmentsImpl class, |
| // it must mean activation.jar is not present and attachments are not |
| // supported. |
| if (isAttachmentSupportEnabled(getMessageContext())) { |
| // Construct one, and cast to Attachments. |
| // There must be exactly one constructor of AttachmentsImpl, which |
| // must take an org.apache.axis.Message! |
| Constructor attachImplConstr = attachImpl.getConstructors()[0]; |
| try { |
| mAttachments = (Attachments) attachImplConstr.newInstance( |
| new Object[] { initialContents, |
| contentType, contentLocation}); |
| |
| //If it can't support it, it wont have a root part. |
| mSOAPPart = (SOAPPart) mAttachments.getRootPart(); |
| } catch (InvocationTargetException ex) { |
| log.fatal(Messages.getMessage("invocationTargetException00"), |
| ex); |
| throw new RuntimeException(ex.getMessage()); |
| } catch (InstantiationException ex) { |
| log.fatal(Messages.getMessage("instantiationException00"), |
| ex); |
| throw new RuntimeException(ex.getMessage()); |
| } catch (IllegalAccessException ex) { |
| log.fatal(Messages.getMessage("illegalAccessException00"), |
| ex); |
| throw new RuntimeException(ex.getMessage()); |
| } |
| } else if (contentType != null && contentType.startsWith("multipart")){ |
| throw new RuntimeException(Messages.getMessage("noAttachments")); |
| } |
| |
| // text/xml |
| if (null == mSOAPPart) { |
| mSOAPPart = new SOAPPart(this, initialContents, bodyInStream); |
| } |
| else |
| mSOAPPart.setMessage(this); |
| |
| // The stream was not determined by a more complex type so default to |
| if(mAttachments!=null) mAttachments.setRootPart(mSOAPPart); |
| |
| headers = (mimeHeaders == null) ? new MimeHeaders() : new MimeHeaders(mimeHeaders); |
| } |
| |
| /** |
| * Get this message's SOAPPart. |
| * <p> |
| * Eventually, this should be generalized beyond just SOAP, |
| * but it's hard to know how to do that without necessitating |
| * a lot of casts in client code. Refactoring keeps getting |
| * easier anyhow. |
| * |
| * @return the soap part of this message |
| */ |
| public javax.xml.soap.SOAPPart getSOAPPart() { |
| return mSOAPPart; |
| } |
| |
| // fixme: do we realy need this? Can client code not just call |
| // getSOAPPart().getAsString() or is there some future optimization that |
| // could be hooked in here? |
| /** |
| * Get a string representation of this message's SOAPPart. |
| * |
| * @return the soap part of this message as a <code>String</code> |
| * @throws org.apache.axis.AxisFault if the stringification failed |
| */ |
| public String getSOAPPartAsString() throws org.apache.axis.AxisFault { |
| return mSOAPPart.getAsString(); |
| } |
| |
| // fixme: do we realy need this? Can client code not just call |
| // getSOAPPart().getAsBytes() or is there some future optimization that |
| // could be hooked in here? |
| /** |
| * Get a byte array representation of this message's SOAPPart. |
| * |
| * @return the soap part of this message as a <code>byte[]</code> |
| * @throws org.apache.axis.AxisFault if creating the byte[] failed |
| */ |
| public byte[] getSOAPPartAsBytes() throws org.apache.axis.AxisFault { |
| return mSOAPPart.getAsBytes(); |
| } |
| |
| /** |
| * Get this message's SOAPPart as a SOAPEnvelope. |
| * |
| * @return a SOAPEnvelope containing this message's SOAPPart |
| * @throws AxisFault if this failed |
| */ |
| public SOAPEnvelope getSOAPEnvelope() throws AxisFault { |
| return mSOAPPart.getAsSOAPEnvelope(); |
| } |
| |
| /** |
| * Get the Attachments of this Message. |
| * <p> |
| * If this returns null, then NO ATTACHMENT SUPPORT EXISTS in this |
| * configuration of Axis, and no attachment operations may be |
| * performed. |
| * |
| * @return the <code>Attachments</code> if attachments are supported, null |
| * otherwise |
| */ |
| public Attachments getAttachmentsImpl() { |
| return mAttachments; |
| } |
| |
| /** |
| * Get the content type of the attachments. |
| * |
| * @param sc provides the default content type |
| * @return a <code>String</code> giving the content type of the |
| * attachment |
| * @throws AxisFault if there was an error deducing the content type from |
| * this message |
| */ |
| public String getContentType(SOAPConstants sc) throws AxisFault { |
| boolean soap12 = false; |
| |
| if(sc != null) { |
| if(sc == SOAPConstants.SOAP12_CONSTANTS) { |
| soap12 = true; |
| } |
| } else { |
| // Support of SOAP 1.2 HTTP binding |
| SOAPEnvelope envelope = getSOAPEnvelope(); |
| if (envelope != null) { |
| if (envelope.getSOAPConstants() == SOAPConstants.SOAP12_CONSTANTS) { |
| soap12 = true; |
| } |
| } |
| } |
| |
| String encoding = XMLUtils.getEncoding(this, msgContext);; |
| String ret = sc.getContentType() + "; charset=" + encoding.toLowerCase(); |
| |
| // Support of SOAP 1.2 HTTP binding |
| if (soap12) { |
| ret = HTTPConstants.HEADER_ACCEPT_APPL_SOAP +"; charset=" + encoding; |
| } |
| |
| if (getSendType() != Attachments.SEND_TYPE_NONE && mAttachments != null && |
| 0 != mAttachments.getAttachmentCount()) { |
| ret = mAttachments.getContentType(); |
| } |
| return ret; |
| } |
| |
| private int getSendType() { |
| int sendType = Attachments.SEND_TYPE_NOTSET; |
| if ((msgContext != null) && (msgContext.getService() != null)) { |
| sendType = msgContext.getService().getSendType(); |
| } |
| return sendType; |
| } |
| |
| //This will have to give way someday to HTTP Chunking but for now kludge. |
| /** |
| * Get the content length, including both soap and any attachments. |
| * |
| * @return the total length of this message in bytes |
| * @throws org.apache.axis.AxisFault if there was a problem that prevented |
| * the length being calculated |
| */ |
| public long getContentLength() throws org.apache.axis.AxisFault { |
| long ret = mSOAPPart.getContentLength(); |
| if (mAttachments != null && 0 < mAttachments.getAttachmentCount()) { |
| ret = mAttachments.getContentLength(); |
| } |
| return ret; |
| } |
| |
| /** |
| * Writes this <CODE>SOAPMessage</CODE> object to the given |
| * output stream. The externalization format is as defined by |
| * the SOAP 1.1 with Attachments specification. |
| * |
| * <P>If there are no attachments, just an XML stream is |
| * written out. For those messages that have attachments, |
| * <CODE>writeTo</CODE> writes a MIME-encoded byte stream.</P> |
| * @param os the <CODE>OutputStream</CODE> |
| * object to which this <CODE>SOAPMessage</CODE> object will |
| * be written |
| * @throws SOAPException if there was a problem in |
| * externalizing this SOAP message |
| * @throws IOException if an I/O error |
| * occurs |
| */ |
| public void writeTo(java.io.OutputStream os) throws SOAPException, IOException { |
| //Do it the old fashion way. |
| if (getSendType() == Attachments.SEND_TYPE_NONE || mAttachments == null || 0 == mAttachments.getAttachmentCount()) { |
| try { |
| String charEncoding = XMLUtils.getEncoding(this, msgContext);; |
| mSOAPPart.setEncoding(charEncoding); |
| mSOAPPart.writeTo(os); |
| } catch (java.io.IOException e) { |
| log.error(Messages.getMessage("javaIOException00"), e); |
| } |
| } else { |
| try { |
| mAttachments.writeContentToStream(os); |
| } catch (java.lang.Exception e) { |
| log.error(Messages.getMessage("exception00"), e); |
| } |
| } |
| } |
| |
| private java.util.Hashtable mProps = new java.util.Hashtable(); |
| |
| public SOAPBody getSOAPBody() throws SOAPException { |
| return mSOAPPart.getEnvelope().getBody(); |
| } |
| |
| public SOAPHeader getSOAPHeader() throws SOAPException { |
| return mSOAPPart.getEnvelope().getHeader(); |
| } |
| |
| public void setProperty(String property, Object value) throws SOAPException { |
| mProps.put(property, value); |
| } |
| |
| public Object getProperty(String property) throws SOAPException { |
| return mProps.get(property); |
| } |
| |
| /** |
| * Retrieves a description of this <CODE>SOAPMessage</CODE> |
| * object's content. |
| * @return a <CODE>String</CODE> describing the content of this |
| * message or <CODE>null</CODE> if no description has been |
| * set |
| * @see #setContentDescription(java.lang.String) setContentDescription(java.lang.String) |
| */ |
| public String getContentDescription() { |
| String values[] = headers.getHeader(HTTPConstants.HEADER_CONTENT_DESCRIPTION); |
| if(values != null && values.length > 0) |
| return values[0]; |
| return null; |
| } |
| |
| /** |
| * Sets the description of this <CODE>SOAPMessage</CODE> |
| * object's content with the given description. |
| * @param description a <CODE>String</CODE> |
| * describing the content of this message |
| * @see #getContentDescription() getContentDescription() |
| */ |
| public void setContentDescription(String description) { |
| headers.setHeader(HTTPConstants.HEADER_CONTENT_DESCRIPTION, description); |
| } |
| |
| /** |
| * Updates this <CODE>SOAPMessage</CODE> object with all the |
| * changes that have been made to it. This method is called |
| * automatically when a message is sent or written to by the |
| * methods <CODE>ProviderConnection.send</CODE>, <CODE> |
| * SOAPConnection.call</CODE>, or <CODE> |
| * SOAPMessage.writeTo</CODE>. However, if changes are made to |
| * a message that was received or to one that has already been |
| * sent, the method <CODE>saveChanges</CODE> needs to be |
| * called explicitly in order to save the changes. The method |
| * <CODE>saveChanges</CODE> also generates any changes that |
| * can be read back (for example, a MessageId in profiles that |
| * support a message id). All MIME headers in a message that |
| * is created for sending purposes are guaranteed to have |
| * valid values only after <CODE>saveChanges</CODE> has been |
| * called. |
| * |
| * <P>In addition, this method marks the point at which the |
| * data from all constituent <CODE>AttachmentPart</CODE> |
| * objects are pulled into the message.</P> |
| * @throws SOAPException if there |
| * was a problem saving changes to this message. |
| */ |
| public void saveChanges() throws SOAPException { |
| headers.removeHeader("Content-Length"); |
| if (mAttachments != null && 0 < mAttachments.getAttachmentCount()) { |
| try { |
| headers.setHeader("Content-Type",mAttachments.getContentType()); |
| } catch (AxisFault af){ |
| log.error(Messages.getMessage("exception00"), af); |
| } |
| } |
| saveRequired = false; |
| try { |
| /* Fix for Bug 16418 - Start from scratch */ |
| mSOAPPart.saveChanges(); |
| } catch (AxisFault axisFault) { |
| log.error(Messages.getMessage("exception00"), axisFault); |
| } |
| } |
| |
| /** |
| * Indicates whether this <CODE>SOAPMessage</CODE> object |
| * has had the method <CODE>saveChanges</CODE> called on |
| * it. |
| * @return <CODE>true</CODE> if <CODE>saveChanges</CODE> has |
| * been called on this message at least once; <CODE> |
| * false</CODE> otherwise. |
| */ |
| public boolean saveRequired() { |
| return saveRequired; |
| } |
| |
| /** |
| * Returns all the transport-specific MIME headers for this |
| * <CODE>SOAPMessage</CODE> object in a transport-independent |
| * fashion. |
| * @return a <CODE>MimeHeaders</CODE> object containing the |
| * <CODE>MimeHeader</CODE> objects |
| */ |
| public javax.xml.soap.MimeHeaders getMimeHeaders() { |
| return headers; |
| } |
| |
| /** |
| * Removes all <CODE>AttachmentPart</CODE> objects that have |
| * been added to this <CODE>SOAPMessage</CODE> object. |
| * |
| * <P>This method does not touch the SOAP part.</P> |
| */ |
| public void removeAllAttachments(){ |
| mAttachments.removeAllAttachments(); |
| } |
| |
| /** |
| * Gets a count of the number of attachments in this |
| * message. This count does not include the SOAP part. |
| * @return the number of <CODE>AttachmentPart</CODE> objects |
| * that are part of this <CODE>SOAPMessage</CODE> |
| * object |
| */ |
| public int countAttachments(){ |
| return mAttachments == null ? 0 : mAttachments.getAttachmentCount(); |
| } |
| |
| /** |
| * Retrieves all the <CODE>AttachmentPart</CODE> objects |
| * that are part of this <CODE>SOAPMessage</CODE> object. |
| * @return an iterator over all the attachments in this |
| * message |
| */ |
| public Iterator getAttachments(){ |
| try { |
| if (mAttachments != null && 0 != mAttachments.getAttachmentCount()) { |
| return mAttachments.getAttachments().iterator(); |
| } |
| } catch (AxisFault af){ |
| log.error(Messages.getMessage("exception00"), af); |
| } |
| return Collections.EMPTY_LIST.iterator(); |
| } |
| |
| /** |
| * Retrieves all the <CODE>AttachmentPart</CODE> objects |
| * that have header entries that match the specified headers. |
| * Note that a returned attachment could have headers in |
| * addition to those specified. |
| * @param headers a <CODE>MimeHeaders</CODE> |
| * object containing the MIME headers for which to |
| * search |
| * @return an iterator over all attachments that have a header |
| * that matches one of the given headers |
| */ |
| public Iterator getAttachments(javax.xml.soap.MimeHeaders headers){ |
| return mAttachments.getAttachments(headers); |
| } |
| |
| /** |
| * Adds the given <CODE>AttachmentPart</CODE> object to this |
| * <CODE>SOAPMessage</CODE> object. An <CODE> |
| * AttachmentPart</CODE> object must be created before it can be |
| * added to a message. |
| * @param attachmentpart an <CODE> |
| * AttachmentPart</CODE> object that is to become part of |
| * this <CODE>SOAPMessage</CODE> object |
| * @throws java.lang.IllegalArgumentException |
| */ |
| public void addAttachmentPart(AttachmentPart attachmentpart){ |
| try { |
| mAttachments.addAttachmentPart((org.apache.axis.Part)attachmentpart); |
| } catch (AxisFault af){ |
| log.error(Messages.getMessage("exception00"), af); |
| } |
| } |
| |
| /** |
| * Creates a new empty <CODE>AttachmentPart</CODE> object. |
| * Note that the method <CODE>addAttachmentPart</CODE> must be |
| * called with this new <CODE>AttachmentPart</CODE> object as |
| * the parameter in order for it to become an attachment to this |
| * <CODE>SOAPMessage</CODE> object. |
| * @return a new <CODE>AttachmentPart</CODE> object that can be |
| * populated and added to this <CODE>SOAPMessage</CODE> |
| * object |
| */ |
| public AttachmentPart createAttachmentPart() { |
| if (!isAttachmentSupportEnabled(getMessageContext())) { |
| throw new RuntimeException(Messages.getMessage("noAttachments")); |
| } |
| |
| try { |
| return (AttachmentPart) mAttachments.createAttachmentPart(); |
| } catch (AxisFault af){ |
| log.error(Messages.getMessage("exception00"), af); |
| } |
| return null; |
| } |
| |
| /** |
| * Dispose of attachments. |
| */ |
| public void dispose() { |
| if(mAttachments!=null) { |
| mAttachments.dispose(); |
| } |
| } |
| } |
