/*
    *  Copyright (c) 2008 Rodrigo Ruiz
    *
    *  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.message.addressing;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  import javax.xml.namespace.QName;
  import javax.xml.soap.Name;
  import javax.xml.soap.SOAPEnvelope;
  import javax.xml.soap.SOAPException;
  import javax.xml.soap.SOAPHeader;
  import javax.xml.soap.SOAPHeaderElement;
  
  import org.apache.axis.AxisFault;
  import org.apache.axis.MessageContext;
  import org.apache.axis.message.MessageElement;
  import org.apache.axis.message.addressing.util.AddressingUtils;
  import org.apache.axis.message.addressing.util.TextExtractor;
  import org.apache.axis.types.URI;
  import org.apache.axis.types.URI.MalformedURIException;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.w3c.dom.Element;
  
  /**
   * Represents a set of message addressing headers as defined by the
   * WS-Addressing specification.
   *
   * @author Davanum Srinivas
   * @author Rodrigo Ruiz
   * @version $Revision: 14 $
   */
  public class AddressingHeaders {
  
    /**
     * Class logger.
     */
    private static final Log LOG = LogFactory.getLog(AddressingHeaders.class);
  
    /**
     * Are we using the W3C spec rules? (no ref props, etc...)
     */
    public boolean isW3CVersion;
  
    /**
     * Field action.
     */
    private Action action;
  
    /**
     * Field replyTo.
     */
    private ReplyTo replyTo;
  
    /**
     * Field to.
     */
    private To to;
  
    /**
     * Field faultTo.
     */
    private FaultTo faultTo;
  
    /**
     * Field from.
     */
    private From from;
  
    /**
     * Field recipient.
     */
    private Recipient recipient;
  
    /**
     * Field messageID.
     */
    private MessageID messageID;
  
    /**
     * Field relatesTo.
     */
    private List<RelatesTo> relatesTo;
  
   /**
    * Field ReferenceProperties.
    */
   private ReferencePropertiesType referenceProperties;
 
   /**
    * Field ReferenceParameters.
    */
   private ReferenceParametersType referenceParameters;
 
   /**
    * Option to set mustUnderstand="true" on the headers or not.
    */
   private boolean setMustUnderstand;
 
   /**
    * If there is a fault while building the headers, it gets put here.
    */
   private AddressingHeaderFault addrHeaderFault;
 
   /**
    * Constructor AddressingHeaders.
    */
   public AddressingHeaders() {
     this.referenceProperties = new ReferencePropertiesType();
     this.referenceParameters = new ReferenceParametersType();
     this.relatesTo = new ArrayList<RelatesTo>();
   }
 
   /**
    * Copy constructor.
    *
    * @param epr Reference to copy from
    */
   public AddressingHeaders(EndpointReference epr) {
     this.to = new To(epr.getAddress());
     this.referenceProperties = epr.getProperties();
     this.referenceParameters = epr.getParameters();
   }
 
   /**
    * Constructor AddressingHeaders.
    *
    * @param env Envelope to get the headers from
    * @throws Exception If an error occurs
    */
   public AddressingHeaders(SOAPEnvelope env) throws Exception {
     this(env, null, true, false, true, new ArrayList<QName>(0));
   }
 
   /**
    * Constructor AddressingHeaders.
    *
    * @param env        Parent Envelope
    * @param process    Should the headers be marked as processed
    * @param remove     Should the headers be removed after processing
    * @throws Exception If an error occurs
    */
   public AddressingHeaders(SOAPEnvelope env, boolean process, boolean remove)
     throws Exception {
     this(env, null, process, remove, true, new ArrayList<QName>(0));
   }
 
   /**
    * Constructor AddressingHeaders.
    *
    * @param env        Parent Envelope
    * @param actorURI   Actor URI
    * @param process    Should the headers be marked as processed
    * @param remove     Should the headers be removed after processing
    * @throws Exception If an error occurs
    */
   public AddressingHeaders(SOAPEnvelope env, String actorURI, boolean process,
     boolean remove) throws Exception {
     this(env, actorURI, process, remove, true, new ArrayList<QName>(0));
   }
 
   /**
    * Constructor AddressingHeaders.
    *
    * @param env The SOAP Envelope
    * @param actorURI The SOAP Actor URI
    * @param process Should the headers be marked as processed
    * @param remove Should the headers be removed after processing
    * @param setMustUnderstand whether or not to set mustUnderstand="true" on the
    *        headers
    * @param allowNonSpecificActions whether or not to allow a non-specific
    *        Action URI
    * @param refPropsQNames A list of QNames for reference properties. If null
    *        all non-WSA headers will be added as reference properties. If an
    *        empty list is passed than no headers will be added reference
    *        properties (default). If non empty list of qnames is passed then
    *        only headers matching the qname in the list will be added as
    *        reference properties.
    * @throws Exception
    */
   public AddressingHeaders(SOAPEnvelope env, String actorURI, boolean process,
     boolean remove, boolean setMustUnderstand, boolean allowNonSpecificActions,
     List<QName> refPropsQNames) throws Exception {
     this();
 
     this.setMustUnderstand = setMustUnderstand;
 
     SOAPHeader header = env.getHeader();
     if (header == null) {
       return;
     }
 
     Iterator<?> iter = header.examineHeaderElements(actorURI);
 
     while (iter.hasNext()) {
       SOAPHeaderElement elem = (SOAPHeaderElement) iter.next();
       if (addHeader(elem, allowNonSpecificActions, refPropsQNames)) {
 
         // !!! We shouldn't be removing these headers here. The only
         // reason to remove them is for use as an intermediary, and
         // that should work via the infrastructure, NOT by removing
         // headers here. Removing them here just means other handlers
         // which run after this one don't see the whole message, which
         // is bad. Change awaiting discussion on fx-dev. --Glen
 
         // must have found one
         if (remove) {
           elem.detachNode();
         }
 
         // axis specific call
         if (process && elem instanceof org.apache.axis.message.SOAPHeaderElement) {
           ((org.apache.axis.message.SOAPHeaderElement) elem).setProcessed(true);
         }
 
       }
     }
   }
 
   /**
    * Constructor AddressingHeaders.
    *
    * @param env The SOAP Envelope
    * @param actorURI The SOAP Actor URI
    * @param process Should the headers be marked as processed
    * @param remove Should the headers be removed after processing
    * @param setMustUnderstand whether or not to set mustUnderstand="true" on the
    *        headers
    * @param refPropsQNames A list of QNames for reference properties. If null
    *        all non-WSA headers will be added as reference properties. If an
    *        empty list is passed than no headers will be added reference
    *        properties (default). If non empty list of qnames is passed then
    *        only headers matching the qname in the list will be added as
    *        reference properties.
    * @throws Exception
    */
   public AddressingHeaders(SOAPEnvelope env, String actorURI, boolean process,
     boolean remove, boolean setMustUnderstand, List<QName> refPropsQNames)
     throws Exception {
     this(env, actorURI, process, remove, setMustUnderstand, false, refPropsQNames);
   }
 
   /**
    * Sets the Action header element, checking duplicates.
    *
    * @param elem Element to set
    * @param allowNonSpecificActions Whether to allow relative Action URIs or not
    * @throws MalformedURIException If an invalid URI is found
    */
   private void addAction(SOAPHeaderElement elem, boolean allowNonSpecificActions)
     throws MalformedURIException {
     // set the WSA namespace URI in the MessageContext,
     // so we'll know how to serialize types associated
     // with this request
     MessageContext msgContext = MessageContext.getCurrentContext();
     if (msgContext != null) {
       msgContext.setProperty(Constants.ENV_ADDRESSING_NAMESPACE_URI,
                              elem.getElementName().getURI());
     }
 
     if (this.action != null) {
       this.addrHeaderFault = new AddressingHeaderFault("duplicate Action header",
         AddressingHeaderFault.INVALID_CARDINALITY, Constants.ACTION);
     }
 
     URI uri = new URI(TextExtractor.getText(elem), allowNonSpecificActions);
     this.action = new Action(uri);
   }
 
   /**
    * Adds a header element to the container.
    *
    * @param headerElement Element to add
    * @param refPropsQNames A list of QNames for reference properties. If null
    *        all non-WSA headers will be added as reference properties. If an
    *        empty list is passed than no headers will be added reference
    *        properties (default). If non empty list of QNames is passed then
    *        only headers matching the QName in the list will be added as
    *        reference properties.
    * @param allowNonSpecificActions Whether to allow relative Action URIs or not
    * @return <tt>true</tt> if the element is an addressing header
    */
   private boolean addHeader(SOAPHeaderElement headerElement,
     boolean allowNonSpecificActions, List<QName> refPropsQNames)
     throws MalformedURIException {
 
     Name name = headerElement.getElementName();
 
     // NOTE : This might want to check consistent use of a single
     // namespace instead of allowing multiple versions....?
 
     AddressingVersion version = AddressingUtils.getAddressingVersion(name.getURI());
 
     if (version != null) {
       // it's a WSA header
       this.isW3CVersion = version.isW3C();
       String localName = name.getLocalName();
 
       if (localName.equals(Constants.MESSAGE_ID)) {
         addMessageID(headerElement);
       } else if (localName.equals(Constants.TO)) {
         addTo(headerElement);
       } else if (localName.equals(Constants.ACTION)) {
         addAction(headerElement, allowNonSpecificActions);
       } else if (localName.equals(Constants.FROM)) {
         addFrom(headerElement);
       } else if (localName.equals(Constants.REPLY_TO)) {
         addReplyTo(headerElement);
       } else if (localName.equals(Constants.FAULT_TO)) {
         addFaultTo(headerElement);
       } else if (localName.equals(Constants.RECIPIENT)) {
         this.recipient = new Recipient(headerElement);
       } else if (localName.equals(Constants.RELATES_TO)) {
         this.relatesTo.add(new RelatesTo(headerElement));
       } else if (localName.equals(Constants.FAULT_DETAIL)) {
         // TODO !!
         LOG.debug("Not done yet");
       } else {
         this.addrHeaderFault = new AddressingHeaderFault(
           "Unsupported addressing header: " + localName, localName);
       }
       return true;
     } else {
       this.isW3CVersion = false;
       // it might be a reference property (wouldn't it be easier
       // if they were all collected under, say wsa:To?)....
       // check if it was added to refProps
       return this.checkReferenceP(headerElement, refPropsQNames);
     }
   }
 
   /**
    * Sets the FaultTo header element, checking duplicates.
    *
    * @param elem Element to set
    * @throws MalformedURIException If an invalid URI is found
    */
   private void addFaultTo(SOAPHeaderElement elem) throws MalformedURIException {
     if (this.faultTo == null) {
       this.faultTo = new FaultTo(elem);
     } else {
       // If this header is duplicated, we cannot assume the previous value is valid
       this.faultTo = null;
       this.addrHeaderFault = new AddressingHeaderFault(
         AddressingHeaderFault.INVALID_CARDINALITY,
         Constants.FAULT_TO);
     }
   }
 
   /**
    * Sets the From header element, checking duplicates.
    *
    * @param elem Element to set
    * @throws MalformedURIException If an invalid URI is found
    */
   private void addFrom(SOAPHeaderElement elem) throws MalformedURIException {
     if (this.from == null) {
       this.from = new From(elem);
     } else {
       this.addrHeaderFault = new AddressingHeaderFault(
         AddressingHeaderFault.INVALID_CARDINALITY,
         Constants.FROM);
     }
   }
 
   /**
    * Sets the MessageID header element, checking duplicates.
    *
    * @param elem Element to set
    * @throws MalformedURIException If an invalid URI is found
    */
   private void addMessageID(SOAPHeaderElement elem) throws MalformedURIException {
     if (this.messageID == null) {
       this.messageID = new MessageID(elem);
     } else {
       this.addrHeaderFault = new AddressingHeaderFault(
         AddressingHeaderFault.INVALID_CARDINALITY,
         Constants.MESSAGE_ID);
     }
   }
 
   /**
    * Adds a reference parameter.
    *
    * @param param Parameter to add
    */
   public void addReferenceParameter(Element param) {
     if (this.referenceParameters == null) {
       this.referenceParameters = new ReferenceParametersType();
     }
     this.referenceParameters.add(param);
   }
 
   /**
    * Adds a reference parameter.
    *
    * @param param Parameter to add
    */
   public void addReferenceParameter(MessageElement param) {
     if (this.referenceParameters == null) {
       this.referenceParameters = new ReferenceParametersType();
     }
     this.referenceParameters.add(param);
   }
 
   /**
    * Adds an XML element to the referencePropeties collection.
    *
    * @param prop Element to add
    */
   public void addReferenceProperty(Element prop) {
     if (this.referenceProperties == null) {
       this.referenceProperties = new ReferencePropertiesType();
     }
     this.referenceProperties.add(prop);
   }
 
   /**
    * Adds a message element to the referencePropeties collection.
    *
    * @param prop Element to add
    */
   public void addReferenceProperty(MessageElement prop) {
     if (this.referenceProperties == null) {
       this.referenceProperties = new ReferencePropertiesType();
     }
     this.referenceProperties.add(prop);
   }
 
   /**
    * Method addRelatesTo.
    *
    * @param uri  Address URI
    * @param type an IRI indicating the relationship type
    * @throws URI.MalformedURIException If the URI is not valid
    */
   public void addRelatesTo(String uri, QName type) throws URI.MalformedURIException {
     this.relatesTo.add(new RelatesTo(uri, type));
   }
 
   /**
    * Method addRelatesTo.
    *
    * @param uri  Address URI
    * @param type an IRI indicating the relationship type
    * @throws URI.MalformedURIException If the URI is not valid
    */
   public void addRelatesTo(String uri, String type) throws URI.MalformedURIException {
     this.relatesTo.add(new RelatesTo(uri, type));
   }
 
   /**
    * Sets the ReplyTo header element, checking duplicates.
    *
    * @param elem Element to set
    * @throws MalformedURIException If an invalid URI is found
    */
   private void addReplyTo(SOAPHeaderElement elem) throws MalformedURIException {
     if (this.replyTo == null) {
       this.replyTo = new ReplyTo(elem);
     } else {
       this.addrHeaderFault = new AddressingHeaderFault(
         AddressingHeaderFault.INVALID_CARDINALITY,
         Constants.REPLY_TO);
     }
   }
 
   /**
    * Sets the To header element, checking duplicates.
    *
    * @param elem Element to set
    * @throws MalformedURIException If an invalid URI is found
    */
   private void addTo(SOAPHeaderElement elem) throws MalformedURIException {
     if (this.to == null) {
       this.to = new To(elem);
     } else {
       this.addrHeaderFault = new AddressingHeaderFault(
         AddressingHeaderFault.INVALID_CARDINALITY,
         Constants.TO);
     }
   }
 
   /**
    * Take a SOAP header, check if it matches one of our reference
    * properties/parameters, if so add it to the appropriate collection.
    *
    * @param headerElement the header to check
    * @param refPropQNames List of property names to match to
    * @return true if it matched, false otherwise
    */
   private boolean checkReferenceP(SOAPHeaderElement headerElement,
     List<QName> refPropQNames) {
     Name name = headerElement.getElementName();
     QName elementName = new QName(name.getURI(), name.getLocalName());
 
     // if we got to this point, the user wants deserialization of ref props.
     // if refPropQNames was a null, it is treated as a '*' or process all
     // headers
     // otherwise we check to see if the element name was specified by the user
     if (refPropQNames == null || refPropQNames.contains(elementName)) {
       this.referenceProperties.add(headerElement);
       return true;
     } else {
       return false;
     }
   }
 
   /**
    * Method getAction.
    *
    * @return The action field
    */
   public Action getAction() {
     return this.action;
   }
 
   /**
    * Gets the fault contained in the headers.
    *
    * @return A fault
    */
   public AxisFault getAddrHeaderFault() {
     return this.addrHeaderFault;
   }
 
   /**
    * Method getFaultTo.
    *
    * @return The FaultTo end-point reference
    */
   public EndpointReference getFaultTo() {
     return this.faultTo;
   }
 
   /**
    * Method getFrom.
    *
    * @return The from field
    */
   public EndpointReference getFrom() {
     return this.from;
   }
 
   /**
    * Method getMessageID.
    *
    * @return The message ID
    */
   public MessageID getMessageID() {
     return this.messageID;
   }
 
   /**
    * Get the reference parameters.
    *
    * @return a List of reference parameters (MessageElements)
    */
   public ReferenceParametersType getReferenceParameters() {
     return this.referenceParameters;
   }
 
   /**
    * Method getReferenceProperties.
    *
    * @return referenceProperties
    */
   public ReferencePropertiesType getReferenceProperties() {
     return this.referenceProperties;
   }
 
   /**
    * Method getRelatesTo.
    *
    * @return The list of RelatesTo fields
    */
   public List<RelatesTo> getRelatesTo() {
     return this.relatesTo;
   }
 
   /**
    * Method getReplyTo.
    *
    * @return The ReplyTo end-point reference
    */
   public EndpointReference getReplyTo() {
     return this.replyTo;
   }
 
   /**
    * Method getTo.
    *
    * @return The To field
    */
   public To getTo() {
     return this.to;
   }
 
   /**
    * Gets the value of the "setMustUnderstand" flag.
    *
    * @return The flag value
    */
   public boolean isSetMustUnderstand() {
     return this.setMustUnderstand;
   }
 
   /**
    * Converts the specified object into a SOAPHeaderElement instance.
    *
    * @param refP Instance to convert
    * @return Resulting header element
    * @throws SOAPException If an error occurs
    */
   private SOAPHeaderElement makeSOAPHeader(Object refP) throws SOAPException {
     SOAPHeaderElement element;
     if (refP instanceof SOAPHeaderElement) {
       // already a SOAPHeaderElement
       element = (SOAPHeaderElement) refP;
     } else if (refP instanceof MessageElement) {
       // conversion from MessageElement to SOAPHeaderElement
       MessageElement msgElement = (MessageElement) refP;
       try {
         element = new org.apache.axis.message.SOAPHeaderElement(msgElement.getAsDOM());
       } catch (SOAPException e) {
         throw e;
       } catch (Exception e) {
         throw new SOAPException(e);
       }
     } else if (refP instanceof Element) {
       Element refPropElement = (Element) refP;
       // conversion from DOM Element
       element = new org.apache.axis.message.SOAPHeaderElement(refPropElement);
     } else {
       throw new SOAPException(refP.getClass().getName());
     }
     return element;
   }
 
   /**
    * Serialize the reference properties/parameters in the SOAP Header.
    *
    * @param env       Envelope to modify
    * @param refPs     List of reference properties
    * @param actorURI  Actor URI
    * @param addAttribute Whether to mark elements as reference properties (W3C version)
    */
   private void serializeReferencePs(SOAPEnvelope env, List<MessageElement> refPs,
     String actorURI, boolean addAttribute) throws SOAPException {
     // If no referenceProps are available, we are done
     if (refPs == null || refPs.size() == 0) {
       return;
     }
 
     SOAPHeaderElement element;
     SOAPHeader header = env.getHeader();
     if (header == null) {
       header = env.addHeader();
     }
 
     // Add each ref property to SOAP Header
     for (MessageElement refProp : refPs) {
       element = this.makeSOAPHeader(refProp);
       element.setActor(actorURI);
 
       // If we're supposed to mark this as a refP, do so (W3C version)
       if (addAttribute) {
         element.addAttribute(Constants.ATTR_REFP, "true");
       }
       header.addChildElement(element);
     }
   }
 
   /**
    * Method setAction.
    *
    * @param action Action field
    */
   public void setAction(Action action) {
     this.action = action;
   }
 
   /**
    * Sets the action URI.
    *
    * @param uri Action URI
    * @throws Exception If an error occurs
    */
   public void setAction(String uri) throws Exception {
     this.action = new Action(new URI(uri));
   }
 
   /**
    * Sets the action URI.
    *
    * @param uri Action URI
    */
   public void setAction(URI uri) {
     this.action = (uri == null) ? null : new Action(uri);
   }
 
   /**
    * Method setFaultTo.
    *
    * @param epr The FaultTo end-point reference
    */
   public void setFaultTo(EndpointReference epr) {
     this.faultTo = new FaultTo(epr);
   }
 
   /**
    * Method setFrom.
    *
    * @param ref From end-point reference
    */
   public void setFrom(EndpointReference ref) {
     this.from = new From(ref);
   }
 
   /**
    * Method setMessageID.
    *
    * @param messageID The message ID to set
    */
   public void setMessageID(MessageID messageID) {
     this.messageID = messageID;
   }
 
   /**
    * Sets the reference parameters.
    *
    * @param params Reference parameters bean
    */
   public void setReferenceParameters(ReferenceParametersType params) {
     this.referenceParameters = params;
   }
 
   /**
    * Method setReferenceProperties.
    *
    * @param props The properties to set
    */
   public void setReferenceProperties(ReferencePropertiesType props) {
     this.referenceProperties = props;
   }
 
   /**
    * Set the collection of RelatesToProperties. Not additive, this replaces the
    * current collection.
    *
    * @param v List of RelatesToProperties
    */
   public void setRelatesTo(List<RelatesTo> v) {
     this.relatesTo.clear();
     this.relatesTo.addAll(v);
   }
 
   /**
    * Method setReplyTo.
    *
    * @param ref The ReplyTo end-point reference
    */
   public void setReplyTo(EndpointReference ref) {
     this.replyTo = new ReplyTo(ref);
   }
 
   /**
    * Sets the "SetMustUnderstand" flag.
    *
    * @param setMustUnderstand Flag value
    */
   public void setSetMustUnderstand(boolean setMustUnderstand) {
     this.setMustUnderstand = setMustUnderstand;
   }
 
   /**
    * Method setTo.
    *
    * @param uri To URI
    */
   public void setTo(AttributedURI uri) {
     this.to = new To(uri);
   }
 
   /**
    * Method setTo.
    *
    * @param to The To field
    */
   public void setTo(To to) {
     this.to = to;
   }
 
   /**
    * Adds these addressing headers to the specified SOAP envelope.
    *
    * @param env Envelope to add to
    * @throws Exception If an error occurs
    */
   public void toEnvelope(SOAPEnvelope env) throws Exception {
     this.toEnvelope(env, null);
   }
 
   /**
    * Adds these addressing headers to the specified SOAP envelope.
    *
    * @param env Envelope to add to
    * @param actorURI Actor URI
    * @throws javax.xml.soap.SOAPException
    */
   public void toEnvelope(SOAPEnvelope env, String actorURI) throws SOAPException {
 
     AddressingVersion version = AddressingUtils.getAddressingVersion();
 
     if (env.getNamespaceURI(Constants.NS_PREFIX_ADDRESSING) == null) {
       env.addNamespaceDeclaration(Constants.NS_PREFIX_ADDRESSING,
                                   version.getNamespace());
     }
 
     AddressingUtils.removeHeaders(env.getHeader(), actorURI);
 
     addItem(version, env, actorURI, this.messageID);
     addItem(version, env, actorURI, this.to);
     addItem(version, env, actorURI, this.action);
     addItem(version, env, actorURI, this.from);
     addItem(version, env, actorURI, this.replyTo);
     addItem(version, env, actorURI, this.faultTo);
     addItem(version, env, actorURI, this.recipient);
 
     if (this.relatesTo != null) {
       for (int i = 0; i < this.relatesTo.size(); i++) {
         AddressingHeaderItem item = this.relatesTo.get(i);
         addItem(version, env, actorURI, item);
       }
     }
 
     if (this.referenceProperties != null && this.referenceProperties.size() > 0) {
       this.serializeReferencePs(env, this.referenceProperties, actorURI, false);
     }
 
     if (this.referenceParameters != null && this.referenceParameters.size() > 0) {
       this.serializeReferencePs(env, this.referenceParameters, actorURI,
         this.isW3CVersion);
     }
   }
 
   /**
    * Adds a SOAPHeaderElement to the headers of the current envelope.
    *
    * @param version   WS-Addressing version to use
    * @param env       Envelope to modify
    * @param actorURI  Actor URI
    * @param item      Element to add
    * @throws SOAPException If an error occurs
    */
   private void addItem(AddressingVersion version, SOAPEnvelope env, String actorURI,
     AddressingHeaderItem item) throws SOAPException {
     if (item != null) {
       SOAPHeaderElement elem = item.toSOAPHeaderElement(version, env, actorURI);
       elem.setMustUnderstand(this.setMustUnderstand);
     }
   }
 }