geronimo-scm mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From xuhaih...@apache.org
Subject svn commit: r1097373 [2/5] - in /geronimo/bundles/trunk/axis2: ./ src/main/java/org/apache/axis2/addressing/ src/main/java/org/apache/axis2/description/ src/main/java/org/apache/axis2/jaxws/addressing/ src/main/java/org/apache/axis2/jaxws/addressing/po...
Date Thu, 28 Apr 2011 09:03:02 GMT
Added: geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/description/WSDL11ToAxisServiceBuilder.java
URL: http://svn.apache.org/viewvc/geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/description/WSDL11ToAxisServiceBuilder.java?rev=1097373&view=auto
==============================================================================
--- geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/description/WSDL11ToAxisServiceBuilder.java (added)
+++ geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/description/WSDL11ToAxisServiceBuilder.java Thu Apr 28 09:03:01 2011
@@ -0,0 +1,3373 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.axis2.description;
+
+import com.ibm.wsdl.util.xml.DOM2Writer;
+import org.apache.axiom.om.OMElement;
+import org.apache.axiom.soap.SOAP11Constants;
+import org.apache.axiom.soap.SOAP12Constants;
+import org.apache.axis2.AxisFault;
+import org.apache.axis2.addressing.AddressingConstants;
+import org.apache.axis2.addressing.AddressingHelper;
+import org.apache.axis2.addressing.EndpointReference;
+import org.apache.axis2.addressing.EndpointReferenceHelper;
+import org.apache.axis2.addressing.wsdl.WSDL11ActionHelper;
+import org.apache.axis2.engine.AxisConfiguration;
+import org.apache.axis2.transport.http.HTTPConstants;
+import org.apache.axis2.util.LoggingControl;
+import org.apache.axis2.util.PolicyUtil;
+import org.apache.axis2.util.XMLUtils;
+import org.apache.axis2.wsdl.SOAPHeaderMessage;
+import org.apache.axis2.wsdl.WSDLConstants;
+import org.apache.axis2.wsdl.WSDLUtil;
+import org.apache.axis2.wsdl.util.WSDLDefinitionWrapper;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.neethi.Constants;
+import org.apache.neethi.Policy;
+import org.apache.neethi.PolicyReference;
+import org.apache.ws.commons.schema.utils.NamespaceMap;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+
+import javax.wsdl.Binding;
+import javax.wsdl.BindingFault;
+import javax.wsdl.BindingInput;
+import javax.wsdl.BindingOperation;
+import javax.wsdl.BindingOutput;
+import javax.wsdl.Definition;
+import javax.wsdl.Fault;
+import javax.wsdl.Import;
+import javax.wsdl.Input;
+import javax.wsdl.Message;
+import javax.wsdl.Operation;
+import javax.wsdl.OperationType;
+import javax.wsdl.Output;
+import javax.wsdl.Part;
+import javax.wsdl.Port;
+import javax.wsdl.PortType;
+import javax.wsdl.Service;
+import javax.wsdl.Types;
+import javax.wsdl.WSDLException;
+import javax.wsdl.extensions.ExtensibilityElement;
+import javax.wsdl.extensions.UnknownExtensibilityElement;
+import javax.wsdl.extensions.http.HTTPAddress;
+import javax.wsdl.extensions.http.HTTPBinding;
+import javax.wsdl.extensions.http.HTTPOperation;
+import javax.wsdl.extensions.http.HTTPUrlEncoded;
+import javax.wsdl.extensions.mime.MIMEContent;
+import javax.wsdl.extensions.mime.MIMEMimeXml;
+import javax.wsdl.extensions.mime.MIMEMultipartRelated;
+import javax.wsdl.extensions.mime.MIMEPart;
+import javax.wsdl.extensions.schema.Schema;
+import javax.wsdl.extensions.soap.SOAPAddress;
+import javax.wsdl.extensions.soap.SOAPBinding;
+import javax.wsdl.extensions.soap.SOAPBody;
+import javax.wsdl.extensions.soap.SOAPHeader;
+import javax.wsdl.extensions.soap.SOAPOperation;
+import javax.wsdl.extensions.soap12.SOAP12Address;
+import javax.wsdl.extensions.soap12.SOAP12Binding;
+import javax.wsdl.extensions.soap12.SOAP12Body;
+import javax.wsdl.extensions.soap12.SOAP12Header;
+import javax.wsdl.extensions.soap12.SOAP12Operation;
+import javax.wsdl.factory.WSDLFactory;
+import javax.wsdl.xml.WSDLLocator;
+import javax.wsdl.xml.WSDLReader;
+import javax.xml.namespace.QName;
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Vector;
+
+public class WSDL11ToAxisServiceBuilder extends WSDLToAxisServiceBuilder {
+
+    public static final int COMPONENT_PORT_TYPE = 1;
+    public static final int COMPONENT_MESSAGE = 2;
+    public static final int COMPONENT_BINDING = 3;
+
+    protected static final Log log = LogFactory
+            .getLog(WSDL11ToAxisServiceBuilder.class);
+    private static final boolean isTraceEnabled = log.isTraceEnabled();
+
+    protected String portName;
+
+    private static final String BINDING = "Binding";
+
+    private static final String SERVICE = "Service";
+
+    private static final String PORT = "Port";
+
+    private static final String PORT_TYPE = "PortType";
+
+    private static final String PORT_TYPE_OPERATION = "PortType.Operation";
+
+    private static final String PORT_TYPE_OPERATION_INPUT = "PortType.Operation.Input";
+
+    private static final String PORT_TYPE_OPERATION_OUTPUT = "PortType.Operation.Output";
+
+    private static final String PORT_TYPE_OPERATION_FAULT = "PortType.Operation.Fault";
+
+    private static final String BINDING_OPERATION = "Binding.Operation";
+
+    private static final String BINDING_OPERATION_INPUT = "Binding.Operation.Input";
+
+    private static final String BINDING_OPERATION_OUTPUT = "Binding.Operation.Output";
+
+    protected Definition wsdl4jDefinition = null;
+    protected String     wsdlBaseDocumentURI = null;
+
+    private WSDLLocator customWSDLResolver;
+
+    public static final String RPC_STYLE = "rpc";
+
+    public static final String DOCUMENT_STYLE = "document";
+
+    public static final String ENCODED_USE = "encoded";
+
+    /**
+     * List of BindingOperationEntry objects.
+     * Each object in the list may require a wrapped schema element for
+     * the input/output or both.
+     */
+    private List wrappableBOEs = new ArrayList();
+    // used to keep the binding type of the selected binding
+    private String bindingType;
+
+    public static final String WRAPPED_OUTPUTNAME_SUFFIX = "Response";
+
+    public static final String XML_NAMESPACE_URI = "http://www.w3.org/2000/xmlns/";
+
+    public static final String NAMESPACE_DECLARATION_PREFIX = "xmlns:";
+
+    private static int prefixCounter = 0;
+
+    public static final String NAMESPACE_URI = "namespace";
+
+    public static final String TRAGET_NAMESPACE = "targetNamespace";
+
+    public static final String BINDING_TYPE_SOAP = "soap";
+    public static final String BINDING_TYPE_HTTP = "http";
+
+    /**
+     * keep track of whether setup code related to the entire wsdl is complete.
+     * Note that WSDL11ToAllAxisServices will call setup multiple times, so this
+     * field is used to make subsequent calls no-ops.
+     */
+    private boolean setupComplete = false;
+
+    private Map schemaMap = null;
+
+    private static final String JAVAX_WSDL_VERBOSE_MODE_KEY = "javax.wsdl.verbose";
+
+    // As bindings are processed add it to this array so that we dont process the same binding twice
+    private Map processedBindings;
+
+    private boolean isAllPorts;
+
+    /**
+     * constructor taking in the service name and the port name
+     *
+     * @param in - InputStream for the WSDL
+     * @param serviceName - The service Name
+     * @param portName - The port name
+     */
+    public WSDL11ToAxisServiceBuilder(InputStream in, QName serviceName,
+                                      String portName) {
+        super(in, serviceName);
+        this.portName = portName;
+    }
+
+    /**
+     * @param def - The WSDL4J Definition object
+     * @param serviceName - The service Name
+     * @param portName - The port name
+     */
+    public WSDL11ToAxisServiceBuilder(Definition def, QName serviceName,
+                                      String portName) {
+        super(null, serviceName);
+        this.wsdl4jDefinition = def;
+        this.portName = portName;
+        this.isAllPorts = false;
+    }
+
+    /**
+     * @param def - The WSDL4J Definition object
+     * @param serviceName - The service Name
+     * @param portName - The port name
+     * @param isAllPorts - boolean representing whether to generate code for all ports or not
+     */
+    public WSDL11ToAxisServiceBuilder(Definition def,
+                                      QName serviceName,
+                                      String portName,
+                                      boolean isAllPorts) {
+        this(def, serviceName, portName);
+        this.isAllPorts = isAllPorts;
+    }
+
+
+    /**
+     * @param in
+     * @param service
+     */
+    public WSDL11ToAxisServiceBuilder(InputStream in, AxisService service) {
+        super(in, service);
+    }
+
+    /**
+     * @param in
+     */
+    public WSDL11ToAxisServiceBuilder(InputStream in) {
+        this(in, null, null);
+    }
+
+    /**
+     * @deprecated
+     * @see setCustomWSDLResolver
+     */
+    public void setCustomWSLD4JResolver(WSDLLocator customResolver) {
+        setCustomWSDLResolver(customResolver);
+    }
+
+
+    /**
+     * sets a custom WSDL locator
+     *
+     * @param customResolver
+     */
+    public void setCustomWSDLResolver(WSDLLocator customResolver) {
+        this.customWSDLResolver = customResolver;
+        setDocumentBaseUri(this.customWSDLResolver.getBaseURI());
+    }
+
+
+    /**
+     * Sets the URI to the base document associated with the WSDL definition.
+     * This identifies the origin of the Definition and allows the
+     * Definition to be reloaded.  Note that this is the URI of the base
+     * document, not the imports.
+     *
+     * @param baseUri
+     */
+    public void setDocumentBaseUri(String baseUri) {
+        if (wsdl4jDefinition != null) {
+            wsdl4jDefinition.setDocumentBaseURI(baseUri);
+        }
+        wsdlBaseDocumentURI = baseUri;
+    }
+
+    /**
+     * Gets the URI to the base document associated with the WSDL definition.
+     * This identifies the origin of the Definition and allows the
+     * Definition to be reloaded.  Note that this is the URI of the base
+     * document, not the imports.
+     *
+     */
+    public String getDocumentBaseUri() {
+        return wsdlBaseDocumentURI;
+    }
+
+
+
+
+    /**
+     * Populates a given service.
+     *
+     * @throws AxisFault
+     */
+    public AxisService populateService() throws AxisFault {
+        try {
+            setup();
+
+            // NOTE: set the axisService with the Parameter for the WSDL
+            // Definition after the rest of the work
+
+            if (wsdl4jDefinition == null) {
+                return null;
+            }
+
+            // setting target name space
+            axisService.setTargetNamespace(wsdl4jDefinition.getTargetNamespace());
+            axisService.setNamespaceMap(new NamespaceMap(wsdl4jDefinition.getNamespaces()));
+
+            Map importsMap = wsdl4jDefinition.getImports();
+
+            if (importsMap != null) {
+                List imports = new ArrayList(importsMap.keySet());
+                axisService.setImportedNamespaces(imports);
+            }
+
+            //TODO : find the service also in imported wsdls
+            Service wsdl4jService = findService(wsdl4jDefinition);
+
+            Binding binding = findBinding(wsdl4jDefinition, wsdl4jService);
+            Definition bindingWSDL = getParentDefinition(wsdl4jDefinition,
+                    binding.getQName(), COMPONENT_BINDING, new HashSet());
+            Definition portTypeWSDL = getParentDefinition(bindingWSDL,
+                    binding.getPortType().getQName(), COMPONENT_PORT_TYPE, new HashSet());
+            PortType portType = portTypeWSDL.getPortType(binding.getPortType().getQName());
+
+
+            if (portType == null) {
+                throw new AxisFault("There is no port type associated with the binding");
+            }
+
+            // create new Schema extensions element for wrapping
+            // (if its present)
+            Element[] schemaElements = generateWrapperSchema(schemaMap, binding, portType);
+
+            processTypes(wsdl4jDefinition, axisService);
+
+            // add the newly created schemas
+            if (schemaElements != null && schemaElements.length > 0) {
+                for (int i = 0; i < schemaElements.length; i++) {
+                    Element schemaElement = schemaElements[i];
+                    if (schemaElement != null) {
+                        axisService.addSchema(getXMLSchema(schemaElement, null));
+                    }
+                }
+            }
+            // copy the documentation element content to the description
+            Element documentationElement = wsdl4jDefinition.getDocumentationElement();
+            addDocumentation(axisService, documentationElement);
+
+            axisService.setName(wsdl4jService.getQName().getLocalPart());
+            populateEndpoints(binding, bindingWSDL,wsdl4jService, portType, portTypeWSDL);
+            processPoliciesInDefintion(wsdl4jDefinition);
+            axisService.getPolicyInclude().setPolicyRegistry(registry);
+
+
+            // Setting wsdl4jdefintion to the axisService parameter include list,
+            // so if someone needs to use the definition directly,
+            // he can do that by getting the parameter
+            Parameter wsdlDefinitionParameter = new Parameter();
+            wsdlDefinitionParameter.setName(WSDLConstants.WSDL_4_J_DEFINITION);
+
+            if (!(wsdl4jDefinition instanceof WSDLDefinitionWrapper)) {
+                AxisConfiguration ac = axisService.getAxisConfiguration();
+                if (ac == null) {
+                    ac = this.axisConfig;
+                }
+                WSDLDefinitionWrapper wrapper = new WSDLDefinitionWrapper(wsdl4jDefinition, ac);
+                wsdlDefinitionParameter.setValue(wrapper);
+            } else {
+                wsdlDefinitionParameter.setValue(wsdl4jDefinition);
+            }
+
+            axisService.addParameter(wsdlDefinitionParameter);
+            axisService.setWsdlFound(true);
+            axisService.setCustomWsdl(true);
+
+
+            return axisService;
+
+        } catch (WSDLException e) {
+            if(log.isDebugEnabled()){
+                log.debug(e.getMessage(), e);
+            }
+            throw AxisFault.makeFault(e);
+        } catch (Exception e) {
+            if(log.isDebugEnabled()){
+                log.debug(e.getMessage(), e);
+            }
+            throw AxisFault.makeFault(e);
+        }
+    }
+
+    private void processTypes(Definition wsdlDefinition, AxisService axisService)
+            throws AxisFault {
+        processTypes(wsdlDefinition, axisService, new HashSet());
+    }
+
+    private void processTypes(Definition wsdlDefinition,
+                              AxisService axisService,
+                              Set visitedWSDLs)
+            throws AxisFault {
+        visitedWSDLs.add(wsdlDefinition.getDocumentBaseURI());
+        // process all the types in all the wsdls
+        Types types = wsdlDefinition.getTypes();
+        if (types != null) {
+            copyExtensibleElements(types.getExtensibilityElements(),
+                                   wsdlDefinition,
+                                   axisService,
+                                   TYPES);
+        }
+
+        // process the types in other wsdls
+        Iterator iter = wsdlDefinition.getImports().values().iterator();
+        Vector values = null;
+        Import wsdlImport = null;
+        for (; iter.hasNext();) {
+            values = (Vector) iter.next();
+            for (Iterator valuesIter = values.iterator(); valuesIter.hasNext();) {
+                wsdlImport = (Import) valuesIter.next();
+                // process the types recuresiveilt
+                Definition innerDefinition = wsdlImport.getDefinition();
+                if(!visitedWSDLs.contains(innerDefinition.getDocumentBaseURI())){
+                    processTypes(innerDefinition, axisService, visitedWSDLs);
+                }
+            }
+        }
+    }
+
+    private void addDocumentation(AxisDescription axisDescription, Element documentationElement) {
+        if ((documentationElement != null) && (documentationElement.getFirstChild() != null)) {
+            Node firstChild = documentationElement.getFirstChild();
+            String documentation = DOM2Writer.nodeToString(firstChild);
+            if (!"".equals(documentation)) {
+                axisDescription.setDocumentation(documentation);
+            }
+        }
+    }
+
+    /**
+     * @param binding
+     * @param wsdl4jService must have atlease one port
+     * @throws AxisFault
+     */
+    private void populateEndpoints(Binding binding,
+                                   Definition bindingWSDL,
+                                   Service wsdl4jService,
+                                   PortType portType,
+                                   Definition portTypeWSDL) throws AxisFault {
+
+        Map wsdl4jPorts = wsdl4jService.getPorts();
+        QName bindingName = binding.getQName();
+
+        Port port;
+        AxisEndpoint axisEndpoint = null;
+
+        processedBindings = new HashMap();
+
+        // process the port type for this binding
+        // although we support multiports they must be belongs to same port type and should have the
+        // same soap style
+        populatePortType(portType, portTypeWSDL);
+
+        Binding currentBinding;
+        Definition currentBindingWSDL = null;
+
+        for (Iterator iterator = wsdl4jPorts.values().iterator(); iterator.hasNext();) {
+            port = (Port) iterator.next();
+            // if the user has picked a port then we have to process only that port
+            if ((this.portName == null) || (this.portName.equals(port.getName()))) {
+                // we process the port only if it has the same port type as the selected binding
+                currentBindingWSDL = getParentDefinition(wsdl4jDefinition,
+                        port.getBinding().getQName(), COMPONENT_BINDING, new HashSet());
+                currentBinding = currentBindingWSDL.getBinding(port.getBinding().getQName());
+
+                if (currentBinding.getPortType().getQName().equals(binding.getPortType().getQName())) {
+                    axisEndpoint = new AxisEndpoint();
+                    axisEndpoint.setName(port.getName());
+
+                    if (axisService.getEndpointName() == null &&
+                            bindingName.equals(port.getBinding().getQName())) {
+                        populateEndpoint(axisEndpoint, port, currentBinding,
+                                bindingWSDL, portType, portTypeWSDL, true);
+                        axisService.setEndpointName(axisEndpoint.getName());
+                        axisService.setBindingName(axisEndpoint.getBinding().getName().getLocalPart());
+                    } else {
+                        populateEndpoint(axisEndpoint, port, currentBinding,
+                                bindingWSDL, portType, portTypeWSDL, false);
+                    }
+
+                    axisEndpoint.setParent(axisService);
+                    axisService.addEndpoint(port.getName(), axisEndpoint);
+                }
+            }
+        }
+    }
+
+    /**
+     * setting message qname is a binding dependent process for an example message element depends on the
+     * soap style (rpc or document) and parts elememet of the soap body
+     * On the otherhand we keep only one set of axis operations belongs to a selected port type in axis service
+     * So setting qname refetences done only with the selected binding processing
+     *
+     * @param axisEndpoint
+     * @param wsdl4jPort
+     * @param isSetMessageQNames
+     * @throws AxisFault
+     */
+    private void populateEndpoint(AxisEndpoint axisEndpoint,
+                                  Port wsdl4jPort,
+                                  Binding wsdl4jBinding,
+                                  Definition bindingWSDL,
+                                  PortType portType,
+                                  Definition portTypeWSDL,
+                                  boolean isSetMessageQNames)
+            throws AxisFault {
+
+        copyExtensibleElements(wsdl4jPort.getExtensibilityElements(), wsdl4jDefinition,
+                               axisEndpoint, BINDING);
+        processEmbeddedEPR(wsdl4jPort.getExtensibilityElements(), axisEndpoint);
+        addDocumentation(axisEndpoint, wsdl4jPort.getDocumentationElement());
+        if (processedBindings.containsKey(wsdl4jBinding.getQName())) {
+            axisEndpoint.setBinding(
+                    (AxisBinding) processedBindings.get(wsdl4jBinding.getQName()));
+        } else {
+            AxisBinding axisBinding = new AxisBinding();
+            axisBinding.setName(wsdl4jBinding.getQName());
+            axisBinding.setParent(axisEndpoint);
+            axisEndpoint.setBinding(axisBinding);
+            axisBinding.setParent(axisEndpoint);
+            populateBinding(axisBinding,
+                    wsdl4jBinding,
+                    bindingWSDL,
+                    portType,
+                    portTypeWSDL,
+                    isSetMessageQNames);
+            processedBindings.put(wsdl4jBinding.getQName(), axisBinding);
+        }
+    }
+
+    private void processEmbeddedEPR(List extensibilityElements, AxisEndpoint axisEndpoint) {
+    	Iterator eelts = extensibilityElements.iterator();
+    	while(eelts.hasNext()){
+    		ExtensibilityElement ee = (ExtensibilityElement)eelts.next();
+    		if(AddressingConstants.Final.WSA_ENDPOINT_REFERENCE.equals(ee.getElementType())){
+    			try {
+    				Element elt = ((UnknownExtensibilityElement)ee).getElement();
+    				OMElement eprOMElement = XMLUtils.toOM(elt);
+    				EndpointReference epr = EndpointReferenceHelper.fromOM(eprOMElement);
+    				Map referenceParameters = epr.getAllReferenceParameters();
+    				if(referenceParameters != null){
+    					axisEndpoint.addParameter(AddressingConstants.REFERENCE_PARAMETER_PARAMETER, new ArrayList(referenceParameters.values()));
+    				}
+    			} catch (Exception e) {
+    				if(log.isDebugEnabled()){
+    					log.debug("Exception encountered processing embedded wsa:EndpointReference", e);
+    				}
+    			}
+    		}
+    	}
+    }
+
+	private void populatePortType(PortType wsdl4jPortType,
+                                  Definition portTypeWSDL) throws AxisFault {
+		copyExtensionAttributes(wsdl4jPortType.getExtensionAttributes(),
+				axisService, PORT_TYPE);
+        List wsdl4jOperations = wsdl4jPortType.getOperations();
+
+        // Added to use in ?wsdl2 as the interface name
+        axisService.addParameter(new Parameter(WSDL2Constants.INTERFACE_LOCAL_NAME,
+                                               wsdl4jPortType.getQName().getLocalPart()));
+        if (wsdl4jOperations.size() < 1) {
+            throw new AxisFault("No operation found in the portType element");
+        }
+
+        AxisOperation axisOperation;
+        List operationNames = new ArrayList();
+
+        QName opName;
+        Operation wsdl4jOperation;
+
+        for (Iterator iterator = wsdl4jOperations.iterator(); iterator.hasNext();) {
+            wsdl4jOperation = (Operation) iterator.next();
+
+            axisOperation = populateOperations(wsdl4jOperation, wsdl4jPortType, portTypeWSDL);
+            addDocumentation(axisOperation, wsdl4jOperation.getDocumentationElement());
+            if (wsdl4jOperation.getInput() != null) {
+                addMessageDocumentation(axisOperation, wsdl4jOperation.getInput().getDocumentationElement(), WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+            }
+            if (wsdl4jOperation.getOutput() != null) {
+                addMessageDocumentation(axisOperation, wsdl4jOperation.getOutput().getDocumentationElement(), WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
+            }
+            axisOperation.setParent(axisService);
+            axisService.addChild(axisOperation);
+            operationNames.add(axisOperation.getName());
+        }
+
+        // this is used only in codegen to preserve operation order
+        if (isCodegen) {
+            axisService.setOperationsNameList(operationNames);
+        }
+
+    }
+
+    /**
+     * This method is used for adding documentation for the message types of the service operations
+     * eg: input message
+     *     output message
+     *     fault messages
+     *
+     * @param axisOperation
+     * @param documentationElement
+     * @param messageLabel
+     */
+    private void addMessageDocumentation(AxisOperation axisOperation, Element documentationElement, String messageLabel) {
+        if ((documentationElement != null) && (documentationElement.getFirstChild() != null)) {
+            Node firstChild = documentationElement.getFirstChild();
+            String documentation = DOM2Writer.nodeToString(firstChild);
+
+            if (!"".equals(documentation)) {
+                (axisOperation.getMessage(messageLabel)).setDocumentation(documentation);
+            }
+        }
+    }
+
+    private void populateBinding(AxisBinding axisBinding,
+                                 Binding wsdl4jBinding,
+                                 Definition bindingWSDL,
+                                 PortType portType,
+                                 Definition portTypeWSDL,
+                                 boolean isSetMessageQNames)
+            throws AxisFault {
+
+        copyExtensibleElements(wsdl4jBinding.getExtensibilityElements(), bindingWSDL,
+                               axisBinding, BINDING);
+
+        List wsdl4jBidingOperations = wsdl4jBinding.getBindingOperations();
+
+        if (wsdl4jBidingOperations.size() < 1) {
+            throw new AxisFault("No operation found for the binding");
+        }
+
+        addDocumentation(axisBinding, wsdl4jBinding.getDocumentationElement());
+
+        AxisOperation axisOperation;
+        Operation wsdl4jOperation;
+
+        AxisBindingOperation axisBindingOperation;
+        BindingOperation wsdl4jBindingOperation;
+
+        Map httpLocationMap = createHttpLocationTable();
+        String httpLocation = null;
+
+        for (Iterator iterator = wsdl4jBidingOperations.iterator(); iterator.hasNext();) {
+
+            axisBindingOperation = new AxisBindingOperation();
+            wsdl4jBindingOperation = (BindingOperation) iterator.next();
+            wsdl4jOperation = findOperation(portType, wsdl4jBindingOperation);
+
+            axisBindingOperation.setName(new QName(bindingWSDL.getTargetNamespace(), wsdl4jBindingOperation.getName()));
+            addDocumentation(axisBindingOperation, wsdl4jBindingOperation.getDocumentationElement());
+
+            axisOperation = axisService.getOperation(new QName(portTypeWSDL.getTargetNamespace(), wsdl4jOperation.getName()));
+            axisBindingOperation.setAxisOperation(axisOperation);
+
+            // process ExtensibilityElements of the wsdl4jBinding
+            copyExtensibleElements(wsdl4jBindingOperation.getExtensibilityElements(),
+                                   wsdl4jDefinition, axisBindingOperation, BINDING_OPERATION);
+
+            httpLocation =
+                    (String) axisBindingOperation.getProperty(WSDL2Constants.ATTR_WHTTP_LOCATION);
+            String httpMethod =
+                    (String) axisBindingOperation.getProperty(WSDL2Constants.ATTR_WHTTP_METHOD);
+            if (httpMethod == null || "".equals(httpMethod)) {
+                httpMethod = HTTPConstants.HEADER_POST;
+            }
+            if (httpLocation != null) {
+                httpLocationMap.put(WSDLUtil.getConstantFromHTTPLocation(httpLocation, httpMethod),
+                                    axisBindingOperation.getAxisOperation());
+            }
+
+            BindingInput wsdl4jBindingInput = wsdl4jBindingOperation.getBindingInput();
+
+            if (isServerSide) {
+                if (wsdl4jBindingInput != null &&
+                        WSDLUtil.isInputPresentForMEP(axisOperation.getMessageExchangePattern())) {
+                    AxisBindingMessage axisBindingInMessage = new AxisBindingMessage();
+                    axisBindingInMessage.setParent(axisBindingOperation);
+                    addDocumentation(axisBindingInMessage, wsdl4jBindingInput.getDocumentationElement());
+                    copyExtensibleElements(wsdl4jBindingInput.getExtensibilityElements(),
+                            wsdl4jDefinition,
+                            axisBindingInMessage, BINDING_OPERATION_INPUT);
+
+                    AxisMessage axisInMessage =
+                            axisOperation.getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+                    //This is a hack to get AXIS2-2771 working , I had to copy soap headers
+                    //  from binding message to AxisMessage
+                    List soapHeaders = (List) axisBindingInMessage.getProperty(
+                            WSDL2Constants.ATTR_WSOAP_HEADER);
+                    if (soapHeaders != null) {
+                        for (int i = 0; i < soapHeaders.size(); i++) {
+                            SOAPHeaderMessage headerMessage = (SOAPHeaderMessage) soapHeaders.get(i);
+                            axisInMessage.addSoapHeader(headerMessage);
+                        }
+                    }
+
+                    if (isSetMessageQNames) {
+                        BindingOperationEntry boe = find(wrappableBOEs, wsdl4jBindingOperation);
+                        boolean isWrapped = (boe == null) ? false : boe.isWrappedInput();
+                        addQNameReference(axisInMessage, wsdl4jOperation,
+                                wsdl4jBindingInput,
+                                isWrapped);
+                    }
+
+                    axisBindingInMessage.setAxisMessage(axisInMessage);
+                    axisBindingInMessage.setName(axisInMessage.getName());
+                    axisBindingInMessage.setDirection(axisInMessage.getDirection());
+
+                    axisBindingOperation
+                            .addChild(WSDLConstants.MESSAGE_LABEL_IN_VALUE, axisBindingInMessage);
+                }
+            } else {
+                if (wsdl4jBindingInput != null &&
+                        WSDLUtil.isOutputPresentForMEP(axisOperation.getMessageExchangePattern())) {
+                    AxisBindingMessage axisBindingOutMessage = new AxisBindingMessage();
+                    axisBindingOutMessage.setParent(axisBindingOperation);
+                    addDocumentation(axisBindingOutMessage, wsdl4jBindingInput.getDocumentationElement());
+                    copyExtensibleElements(wsdl4jBindingInput.getExtensibilityElements(),
+                            wsdl4jDefinition,
+                            axisBindingOutMessage, BINDING_OPERATION_OUTPUT);
+
+                    AxisMessage axisOutMessage =
+                            axisOperation.getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
+                    //This is a hack to get AXIS2-2771 working , I had to copy soap headers
+                    //  from binding message to AxisMessage
+                    List soapHeaders = (List) axisBindingOutMessage.getProperty(
+                            WSDL2Constants.ATTR_WSOAP_HEADER);
+                    if (soapHeaders != null) {
+                        for (int i = 0; i < soapHeaders.size(); i++) {
+                            SOAPHeaderMessage headerMessage = (SOAPHeaderMessage) soapHeaders.get(i);
+                            axisOutMessage.addSoapHeader(headerMessage);
+                        }
+                    }
+
+                    if (isSetMessageQNames) {
+                        BindingOperationEntry boe = find(wrappableBOEs, wsdl4jBindingOperation);
+                        boolean isWrapped = (boe == null) ? false : boe.isWrappedInput();
+                        addQNameReference(axisOutMessage, wsdl4jOperation,
+                                wsdl4jBindingInput,
+                                isWrapped);
+                    }
+
+                    axisBindingOutMessage.setAxisMessage(axisOutMessage);
+                    axisBindingOutMessage.setName(axisOutMessage.getName());
+                    axisBindingOutMessage.setDirection(axisOutMessage.getDirection());
+
+                    axisBindingOperation
+                            .addChild(WSDLConstants.MESSAGE_LABEL_OUT_VALUE, axisBindingOutMessage);
+                }
+            }
+
+            BindingOutput wsdl4jBindingOutput = wsdl4jBindingOperation.getBindingOutput();
+
+            if (isServerSide) {
+                if (wsdl4jBindingOutput != null &&
+                        WSDLUtil.isOutputPresentForMEP(axisOperation.getMessageExchangePattern())) {
+
+                    AxisBindingMessage axisBindingOutMessage = new AxisBindingMessage();
+                    axisBindingOutMessage.setParent(axisBindingOperation);
+                    addDocumentation(axisBindingOutMessage, wsdl4jBindingOutput.getDocumentationElement());
+                    AxisMessage axisOutMessage =
+                            axisOperation.getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
+
+                    copyExtensibleElements(wsdl4jBindingOutput.getExtensibilityElements(),
+                            wsdl4jDefinition,
+                            axisBindingOutMessage, BINDING_OPERATION_OUTPUT);
+
+                    //This is a hack to get AXIS2-2771 working , I had to copy soap headers
+                    //  from binding message to AxisMessage
+                    List soapHeaders =
+                            (List) axisBindingOutMessage.getProperty(WSDL2Constants.ATTR_WSOAP_HEADER);
+                    if (soapHeaders != null) {
+                        for (int i = 0; i < soapHeaders.size(); i++) {
+                            SOAPHeaderMessage headerMessage = (SOAPHeaderMessage) soapHeaders.get(i);
+                            axisOutMessage.addSoapHeader(headerMessage);
+                        }
+                    }
+
+                    if (isSetMessageQNames) {
+                        BindingOperationEntry boe = find(wrappableBOEs, wsdl4jBindingOperation);
+                        boolean isWrapped = (boe == null) ? false : boe.isWrappedOutput();
+                        axisOutMessage.setWrapped(isWrapped);
+                        addQNameReference(axisOutMessage, wsdl4jOperation,
+                                wsdl4jBindingOutput,
+                                isWrapped);
+                    }
+
+
+                    axisBindingOutMessage.setAxisMessage(axisOutMessage);
+                    axisBindingOutMessage.setName(axisOutMessage.getName());
+                    axisBindingOutMessage.setDirection(axisOutMessage.getDirection());
+
+                    axisBindingOperation
+                            .addChild(WSDLConstants.MESSAGE_LABEL_OUT_VALUE, axisBindingOutMessage);
+                }
+            } else {
+                if (wsdl4jBindingOutput != null &&
+                        WSDLUtil.isInputPresentForMEP(axisOperation.getMessageExchangePattern())) {
+
+                    AxisBindingMessage axisBindingInMessage = new AxisBindingMessage();
+                    axisBindingInMessage.setParent(axisBindingOperation);
+                    addDocumentation(axisBindingInMessage, wsdl4jBindingOutput.getDocumentationElement());
+                    AxisMessage axisInMessage =
+                            axisOperation.getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+
+                    copyExtensibleElements(wsdl4jBindingOutput.getExtensibilityElements(),
+                            wsdl4jDefinition,
+                            axisBindingInMessage, BINDING_OPERATION_INPUT);
+
+                    //This is a hack to get AXIS2-2771 working , I had to copy soap headers
+                    //  from binding message to AxisMessage
+                    List soapHeaders =
+                            (List) axisBindingInMessage.getProperty(WSDL2Constants.ATTR_WSOAP_HEADER);
+                    if (soapHeaders != null) {
+                        for (int i = 0; i < soapHeaders.size(); i++) {
+                            SOAPHeaderMessage headerMessage = (SOAPHeaderMessage) soapHeaders.get(i);
+                            axisInMessage.addSoapHeader(headerMessage);
+                        }
+                    }
+
+                    if (isSetMessageQNames) {
+                        BindingOperationEntry boe = find(wrappableBOEs, wsdl4jBindingOperation);
+                        boolean isWrapped = (boe == null) ? false : boe.isWrappedOutput();
+                        axisInMessage.setWrapped(isWrapped);
+                        addQNameReference(axisInMessage, wsdl4jOperation,
+                                wsdl4jBindingOutput,
+                                isWrapped);
+                    }
+
+
+                    axisBindingInMessage.setAxisMessage(axisInMessage);
+                    axisBindingInMessage.setName(axisInMessage.getName());
+                    axisBindingInMessage.setDirection(axisInMessage.getDirection());
+
+                    axisBindingOperation
+                            .addChild(WSDLConstants.MESSAGE_LABEL_IN_VALUE, axisBindingInMessage);
+                }
+            }
+
+            Map bindingFaultsMap = wsdl4jBindingOperation.getBindingFaults();
+
+            /* process the binding faults */
+            for (Iterator bindingFaults = bindingFaultsMap.values().iterator();
+                 bindingFaults.hasNext();) {
+
+                BindingFault bindingFault = (BindingFault) bindingFaults.next();
+                if (bindingFault.getName() == null) {
+                    throw new AxisFault("Binding name is null for the binding fault in " +
+                            " binding operation ==> " + wsdl4jBindingOperation.getName());
+                } else {
+                    Fault wsdl4jFault = wsdl4jOperation.getFault(bindingFault.getName());
+                    if (wsdl4jFault == null){
+                        throw new AxisFault("Can not find the corresponding fault element in " +
+                                "wsdl operation " + wsdl4jOperation.getName() + " for the fault" +
+                                " name " + bindingFault.getName());
+                    } else {
+                        Message wsdl4jFaultMessge = wsdl4jFault.getMessage();
+
+                        AxisMessage faultMessage = findFaultMessage(
+                                wsdl4jFault.getName(),
+                                axisOperation.getFaultMessages());
+
+                        AxisBindingMessage axisBindingFaultMessage = new AxisBindingMessage();
+                        addDocumentation(axisBindingFaultMessage, wsdl4jFaultMessge.getDocumentationElement());
+                        axisBindingFaultMessage.setFault(true);
+                        axisBindingFaultMessage.setAxisMessage(faultMessage);
+                        axisBindingFaultMessage.setName(faultMessage.getName());
+                        axisBindingFaultMessage.setParent(axisBindingOperation);
+
+                        axisBindingOperation.addFault(axisBindingFaultMessage);
+                        if (isSetMessageQNames) {
+                            addQNameReference(faultMessage, wsdl4jFault.getMessage());
+                        }
+                    }
+                }
+            }
+
+            axisBindingOperation.setParent(axisBinding);
+            axisBinding.addChild(axisBindingOperation.getName(), axisBindingOperation);
+        }
+        axisBinding.setProperty(WSDL2Constants.HTTP_LOCATION_TABLE, httpLocationMap);
+    }
+
+    /**
+     * contains all code which gathers non-service specific information from the
+     * wsdl. <p/> After all the setup completes successfully, the setupComplete
+     * field is set so that any subsequent calls to setup() will result in a
+     * no-op. Note that subclass WSDL11ToAllAxisServicesBuilder will call
+     * populateService for each port in the WSDL. Separating the non-service
+     * specific information here allows WSDL11ToAllAxisServicesBuilder to only
+     * do this work 1 time per WSDL, instead of for each port on each service.
+     *
+     * @throws WSDLException if readInTheWSDLFile fails
+     */
+    protected void setup() throws WSDLException {
+        if (setupComplete) { // already setup, just do nothing and return
+            return;
+        }
+        if (wsdl4jDefinition == null) {
+            wsdl4jDefinition = readInTheWSDLFile(in);
+        }
+        if (wsdl4jDefinition == null) {
+            return; // can't continue without wsdl
+        }
+
+
+        // setup the schemaMap
+        this.schemaMap = new HashMap();
+        populateSchemaMap(wsdl4jDefinition, new HashSet());
+
+        setPolicyRegistryFromService(axisService);
+
+        setupComplete = true; // if any part of setup fails, don't mark
+        // setupComplete
+    }
+
+
+    /**
+     * Populate a map of targetNamespace vs DOM schema element This is used to
+     * grab the correct schema element when adding a new element
+     *
+     * @param definition
+     */
+
+    private void populateSchemaMap(Definition definition, Set visitedWSDLs) {
+        visitedWSDLs.add(definition.getDocumentBaseURI());
+        // first process the types in the given wsdl
+        Types types = definition.getTypes();
+        Object extensibilityElement;
+        if (types != null) {
+            for (Iterator iterator = types.getExtensibilityElements().iterator(); iterator.hasNext();)
+            {
+                extensibilityElement = iterator.next();
+                if (extensibilityElement instanceof Schema) {
+                    Element schemaElement = ((Schema) extensibilityElement).getElement();
+                    schemaMap.put(schemaElement.getAttribute(XSD_TARGETNAMESPACE), schemaElement);
+                }
+            }
+        }
+
+        // popualte the imports as well
+        Iterator iter = definition.getImports().values().iterator();
+        Vector values = null;
+        Import wsdlImport = null;
+        for (; iter.hasNext();) {
+            values = (Vector) iter.next();
+            for (Iterator valuesIter = values.iterator(); valuesIter.hasNext();) {
+                wsdlImport = (Import) valuesIter.next();
+                Definition innerDefinition = wsdlImport.getDefinition();
+                if(!visitedWSDLs.contains(innerDefinition.getDocumentBaseURI())) {
+                    populateSchemaMap(innerDefinition, visitedWSDLs);
+                }
+            }
+        }
+    }
+
+
+    /**
+     * return the service to process
+     * if user has specified we check whether it exists
+     * else pick a random service and throws an exception if not found any thing
+     *
+     * @param definition
+     * @return service to process
+     * @throws AxisFault
+     */
+
+    private Service findService(Definition definition) throws AxisFault {
+        Map services = definition.getServices();
+        Service service = null;
+        if (serviceName != null) {
+            // i.e if a user has specified a pirticular port
+            service = (Service) services.get(serviceName);
+            if (service == null) {
+                throw new AxisFault("Service " + serviceName
+                                    + " was not found in the WSDL");
+            }
+        } else {
+            if (services.size() > 0) {
+                for (Iterator iter = services.values().iterator(); iter.hasNext();) {
+                    service = (Service) iter.next();
+                    if (service.getPorts().size() > 0) {
+                        //i.e we have found a service with ports
+                        break;
+                    }
+                }
+                if ((service == null) || (service.getPorts().size() == 0)) {
+                    throw new AxisFault("there is no service with ports to pick");
+                }
+
+            } else {
+                throw new AxisFault("No services found in the WSDL at " +
+                                    definition.getDocumentBaseURI()
+                                    + " with targetnamespace "
+                                    + definition.getTargetNamespace());
+            }
+        }
+        return service;
+    }
+
+    /**
+     * Look for the relevant binding!
+     * if user has spcifed a port get it
+     * otherwise find first soap port or pick random one if there is no soap port
+     *
+     * @param dif
+     * @param service service can not be null
+     * @throws AxisFault
+     */
+    private Binding findBinding(Definition dif, Service service) throws AxisFault {
+
+        Binding binding = null;
+        Port port = null;
+        copyExtensibleElements(service.getExtensibilityElements(), dif, axisService, SERVICE);
+        if (portName != null) {
+            // i.e if user has specified a service
+            port = service.getPort(portName);
+            if (port == null) {
+                throw new AxisFault("No port found for the given name :" + portName);
+            }
+        } else {
+            Map ports = service.getPorts();
+            if (ports != null && ports.size() > 0) {
+                // pick the port with the SOAP address as the default port
+                port = findPort(ports);
+                if (port == null) {
+                    // a SOAP port was not found - log a warning
+                    // and use the first port in the list
+                    log.info("A SOAP port was not found - "
+                             + "picking a random port!");
+                    port = (Port) ports.values().toArray()[0];
+                }
+
+                if (port != null) {
+                    // i.e we have find a correct port
+                    // this is only use full in codegen time.
+                    if (this.isCodegen && !this.isAllPorts) {
+                        // if user has not set all option
+                        // we have to generate code only for that option.
+                        this.portName = port.getName();
+                    }
+                }
+            }
+        }
+
+        axisService.setName(service.getQName().getLocalPart());
+
+        if (port != null) {
+            copyExtensibleElements(port.getExtensibilityElements(), dif,
+                                   axisService, PORT);
+            Definition parentDefinition = getParentDefinition(dif,
+                    port.getBinding().getQName(), COMPONENT_BINDING, new HashSet());
+            binding = parentDefinition.getBinding(port.getBinding().getQName());
+            if (binding == null) {
+                binding = port.getBinding();
+            }
+        }
+
+        return binding;
+    }
+
+    /**
+     * Finds a SOAP port given the port map
+     */
+    private Port findPort(Map ports) {
+        Port port;
+        Port returnPort = null;
+        for (Iterator portsIterator = ports.values().iterator(); portsIterator.hasNext();) {
+            port = (Port) portsIterator.next();
+            List extensibilityElements = port.getExtensibilityElements();
+            for (int i = 0; i < extensibilityElements.size(); i++) {
+                Object extElement = extensibilityElements.get(i);
+                if (extElement instanceof SOAP12Address) {
+                    // SOAP 1.2 address found - keep this and loop until http address is found
+                    returnPort = port;
+                    String location = ((SOAP12Address)extElement).getLocationURI().trim();
+                    if ((location != null) && location.startsWith("http:")){
+                        // i.e we have found an http port so return from here
+                       break;
+                    }
+                }
+            }
+        }
+
+        if (returnPort != null){
+            return returnPort;
+        }
+
+        for (Iterator portsIterator = ports.values().iterator(); portsIterator
+                .hasNext();) {
+            port = (Port) portsIterator.next();
+            List extensibilityElements = port.getExtensibilityElements();
+            for (int i = 0; i < extensibilityElements.size(); i++) {
+                Object extElement = extensibilityElements.get(i);
+                if (extElement instanceof SOAPAddress) {
+                    // SOAP 1.1 address found - keep this and loop until http address is found
+                    returnPort = port;
+                    String location = ((SOAPAddress)extElement).getLocationURI().trim();
+                    if ((location != null) && location.startsWith("http:")){
+                        // i.e we have found an http port so return from here
+                       break;
+                    }
+                }
+            }
+        }
+
+        if (returnPort != null){
+            return returnPort;
+        }
+
+        for (Iterator portsIterator = ports.values().iterator(); portsIterator
+                .hasNext();) {
+            port = (Port) portsIterator.next();
+            List extensibilityElements = port.getExtensibilityElements();
+            for (int i = 0; i < extensibilityElements.size(); i++) {
+                Object extElement = extensibilityElements.get(i);
+                if (extElement instanceof HTTPAddress) {
+                    // HTTP address found - keep this and loop until http address is found
+                    returnPort = port;
+                    String location = ((HTTPAddress)extElement).getLocationURI().trim();
+                    if ((location != null) && location.startsWith("http:")){
+                        // i.e we have found an http port so return from here
+                       break;
+                    }
+                }
+            }
+        }
+        return returnPort;
+    }
+
+    private Operation findOperation(PortType portType,
+                                    BindingOperation wsdl4jBindingOperation) {
+        Operation op = wsdl4jBindingOperation.getOperation();
+        String input = null;
+        if (op != null && op.getInput() != null) {
+            input = op.getInput().getName();
+            if (":none".equals(input)) {
+                input = null;
+            }
+        }
+        String output = null;
+        if (op != null && op.getOutput() != null) {
+            output = op.getOutput().getName();
+            if (":none".equals(output)) {
+                output = null;
+            }
+        }
+        Operation op2 = portType.getOperation(op.getName(), input, output);
+        return ((op2 == null) ? op : op2);
+    }
+
+    /**
+     * Find the fault message relevant to a given name from the fault message
+     * list
+     *
+     * @param name
+     * @param faultMessages
+     */
+    private AxisMessage findFaultMessage(String name, ArrayList faultMessages) {
+        AxisMessage tempMessage;
+        for (int i = 0; i < faultMessages.size(); i++) {
+            tempMessage = (AxisMessage) faultMessages.get(i);
+            if (name.equals(tempMessage.getName())) {
+                return tempMessage;
+            }
+
+        }
+        return null;
+    }
+
+    /**
+     * Add the QName for the binding input
+     *
+     * @param inMessage
+     * @param wsdl4jOperation
+     * @param bindingInput
+     * @param isWrapped       - basically whether the operation is soap/rpc or not
+     */
+    private void addQNameReference(AxisMessage inMessage,
+                                   Operation wsdl4jOperation, BindingInput bindingInput,
+                                   boolean isWrapped) {
+
+        List extensibilityElements = bindingInput.getExtensibilityElements();
+        Message wsdl4jMessage = wsdl4jOperation.getInput().getMessage();
+
+        addQNameReference(inMessage,
+                          wsdl4jOperation,
+                          isWrapped,
+                          extensibilityElements,
+                          wsdl4jMessage,
+                          wsdl4jOperation.getName());
+    }
+
+    /**
+     * Add the QName for the binding output
+     *
+     * @param outMessage
+     * @param wsdl4jOperation
+     * @param isWrapped
+     */
+    private void addQNameReference(AxisMessage outMessage,
+                                   Operation wsdl4jOperation, BindingOutput bindingOutput,
+                                   boolean isWrapped) {
+
+        if (bindingOutput != null) {
+            List extensibilityElements = bindingOutput.getExtensibilityElements();
+            if (wsdl4jOperation.getOutput() == null) {
+                return;
+            }
+            Message wsdl4jMessage = wsdl4jOperation.getOutput().getMessage();
+
+            addQNameReference(outMessage,
+                              wsdl4jOperation,
+                              isWrapped,
+                              extensibilityElements,
+                              wsdl4jMessage,
+                              wsdl4jOperation.getName() + WRAPPED_OUTPUTNAME_SUFFIX);
+        }
+    }
+
+    private void addQNameReference(AxisMessage message,
+                                   Operation wsdl4jOperation,
+                                   boolean isWrapped,
+                                   List extensibilityElements,
+                                   Message wsdl4jMessage,
+                                   String rpcOperationName) {
+        if (isWrapped) {
+            // we have already validated and process the qname references
+            // so set it here
+            // The schema for this should be already made ! Find the
+            // QName from
+            // the list and add it - the name for this is just the
+            message.setElementQName((QName) resolvedRpcWrappedElementMap
+                    .get(rpcOperationName));
+            message.getAxisOperation().getAxisService().addMessageElementQNameToOperationMapping(
+                    (QName) resolvedRpcWrappedElementMap.get(rpcOperationName),
+                    message.getAxisOperation());
+        } else {
+            // now we are sure this is an document literal type element
+            List bindingPartsList = getPartsListFromSoapBody(extensibilityElements);
+            if (bindingPartsList == null) {
+                // i.e user has not given any part list so we go to message and pick the firest part if
+                // available
+                if ((wsdl4jMessage.getParts() != null) && (wsdl4jMessage.getParts().size() > 0)) {
+                    if (wsdl4jMessage.getParts().size() == 1) {
+                        Part part = (Part) wsdl4jMessage.getParts().values().iterator().next();
+                        QName elementName = part.getElementName();
+                        if (elementName != null) {
+                            message.setElementQName(elementName);
+                            message.setMessagePartName(part.getName());
+                            AxisOperation operation = message.getAxisOperation();
+                            AxisService service = operation.getAxisService();
+                            service.addMessageElementQNameToOperationMapping(elementName,
+                                                                             operation);
+                        } else {
+                            throw new WSDLProcessingException(
+                                    "No element type is defined for message " +
+                                    wsdl4jMessage.getQName().getLocalPart());
+                        }
+                    } else {
+                        // user has specified more than one parts with out specifing a part in
+                        // soap body
+                        throw new WSDLProcessingException("More than one part for message " +
+                                                          wsdl4jMessage.getQName().getLocalPart());
+                    }
+                } else {
+                    // This is allowed in the spec in this case element qname is null and nothing is send
+                    // in the soap body.  This is true for Doc/Lit/Bare operations that do not have any paramaters.
+                    // In this case, add a mapping of the operation to a null key so the empty body can be routed on
+                    // (for example in SOAPMessageBodyBasedDispatcher).
+                    message.setElementQName(null);
+                    AxisOperation operation = message.getAxisOperation();
+                    AxisService service = operation.getAxisService();
+                    service.addMessageElementQNameToOperationMapping(null, operation);
+                }
+            } else {
+                if (bindingPartsList.size() == 0) {
+                    // we donot have to set the element qname
+                    message.setElementQName(null);
+                } else if (bindingPartsList.size() == 1) {
+                    Part part = wsdl4jMessage.getPart((String) bindingPartsList.get(0));
+                    if (part != null) {
+                        QName elementName = part.getElementName();
+                        if (elementName != null) {
+                            message.setElementQName(elementName);
+                            message.setMessagePartName(part.getName());
+                            AxisOperation operation = message.getAxisOperation();
+                            AxisService service = operation.getAxisService();
+                            service.addMessageElementQNameToOperationMapping(elementName,
+                                                                             operation);
+                        } else {
+                            throw new WSDLProcessingException(
+                                    "No element type is defined for message" +
+                                    wsdl4jMessage.getQName().getLocalPart());
+                        }
+                    } else {
+                        throw new WSDLProcessingException("Missing part named "
+                                                          + bindingPartsList.get(0) + " ");
+                    }
+
+                } else {
+                    // i.e more than one part specified in this case we have
+                    // to send an exception
+                    throw new WSDLProcessingException(
+                            "More than one element part is not allwed in document literal " +
+                            " type binding operation " + wsdl4jOperation.getName());
+                }
+            }
+
+        }
+
+    }
+
+    /**
+     * Add the QName for the binding output
+     */
+    private void addQNameReference(AxisMessage faultMessage,
+                                   Message wsdl4jMessage) throws AxisFault {
+
+        // for a fault this is trivial - All faults are related directly to a
+        // message by the name and are supposed to have a single part. So it is
+        // a matter of copying the right QName from the message part
+
+        // get the part
+        Map parts = wsdl4jMessage.getParts();
+        if (parts == null || parts.size() == 0) {
+            String message = "There are no parts"
+                             + " for fault message : "
+                             + wsdl4jMessage.getQName();
+            log.error(message);
+            throw new WSDLProcessingException(message);
+        }
+        Part wsdl4jMessagePart = (Part) parts.values()
+                .toArray()[0];
+        if (wsdl4jMessagePart == null) {
+            throw new WSDLProcessingException();
+        }
+        QName name = wsdl4jMessagePart.getElementName();
+        if (name == null) {
+            String message = "Part '"
+                             + wsdl4jMessagePart.getName()
+                             + "' of fault message '"
+                             + wsdl4jMessage.getQName()
+                             + "' must be defined with 'element=QName' and not 'type=QName'";
+            log.error(message);
+            throw new AxisFault(message);
+        }
+
+        faultMessage.setMessagePartName(wsdl4jMessagePart.getName());
+        faultMessage.setElementQName(name);
+    }
+
+    /**
+     * A util method that returns the SOAP style included in the binding
+     * operation
+     *
+     * @param bindingOp
+     */
+    private String getSOAPStyle(BindingOperation bindingOp) {
+        List extensibilityElements = bindingOp.getExtensibilityElements();
+        for (int i = 0; i < extensibilityElements.size(); i++) {
+            Object extElement = extensibilityElements.get(i);
+            if (extElement instanceof SOAPOperation) {
+                return ((SOAPOperation) extElement).getStyle();
+            } else if (extElement instanceof SOAP12Operation) {
+                return ((SOAP12Operation) extElement).getStyle();
+            }
+
+        }
+        return null;
+    }
+
+    /**
+     * Copy the component from the operation
+     *
+     * @param wsdl4jOperation
+     * @param dif
+     * @throws AxisFault
+     */
+    private AxisOperation populateOperations(Operation wsdl4jOperation,
+                                             PortType wsdl4jPortType, Definition dif)
+            throws AxisFault {
+        QName opName = new QName(dif.getTargetNamespace(), wsdl4jOperation.getName());
+        // Copy Name Attribute
+        AxisOperation axisOperation = axisService.getOperation(opName);
+        if (axisOperation == null) {
+            String MEP = getMEP(wsdl4jOperation);
+            axisOperation = AxisOperationFactory.getOperationDescription(MEP);
+            axisOperation.setName(opName);
+
+            // setting the PolicyInclude property of the AxisOperation
+            PolicyInclude policyInclude = new PolicyInclude(axisOperation);
+            axisOperation.setPolicyInclude(policyInclude);
+        }
+
+        copyExtensionAttributes(wsdl4jOperation.getExtensionAttributes(),
+                               axisOperation, PORT_TYPE_OPERATION);
+
+        Input wsdl4jInputMessage = wsdl4jOperation.getInput();
+
+        if (isServerSide) {
+            if (null != wsdl4jInputMessage) {
+                AxisMessage inMessage = axisOperation
+                        .getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+                Message message = wsdl4jInputMessage.getMessage();
+                if (null != message) {
+                    inMessage.setName(message.getQName().getLocalPart());
+                    copyExtensionAttributes(wsdl4jInputMessage.getExtensionAttributes(),
+                                           inMessage, PORT_TYPE_OPERATION_INPUT);
+
+                }
+                // Check if the action is already set as we don't want to
+                // override it
+                // with the Default Action Pattern
+                ArrayList inputActions = axisOperation.getWSAMappingList();
+                String action = null;
+                if (inputActions == null || inputActions.size() == 0) {
+                    action = WSDL11ActionHelper
+                            .getActionFromInputElement(dif, wsdl4jPortType,
+                                                       wsdl4jOperation, wsdl4jInputMessage);
+                }
+                if (action != null) {
+                    if (inputActions == null) {
+                        inputActions = new ArrayList();
+                        axisOperation.setWsamappingList(inputActions);
+                    }
+                    inputActions.add(action);
+                    axisService.mapActionToOperation(action, axisOperation);
+                }
+            }
+            // Create an output message and add
+            Output wsdl4jOutputMessage = wsdl4jOperation.getOutput();
+            if (null != wsdl4jOutputMessage) {
+                AxisMessage outMessage = axisOperation
+                        .getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
+                Message message = wsdl4jOutputMessage.getMessage();
+                if (null != message) {
+
+                    outMessage.setName(message.getQName().getLocalPart());
+                    copyExtensionAttributes(wsdl4jOutputMessage.getExtensionAttributes(),
+                                           outMessage, PORT_TYPE_OPERATION_OUTPUT);
+
+                    // wsdl:portType -> wsdl:operation -> wsdl:output
+                }
+                // Check if the action is already set as we don't want to
+                // override it
+                // with the Default Action Pattern
+                String action = axisOperation.getOutputAction();
+                if (action == null) {
+                    action = WSDL11ActionHelper.getActionFromOutputElement(dif,
+                                                                           wsdl4jPortType,
+                                                                           wsdl4jOperation,
+                                                                           wsdl4jOutputMessage);
+                }
+                if (action != null) {
+                    axisOperation.setOutputAction(action);
+                }
+            }
+        } else {
+
+            // for the client side we have to do something that is a bit
+            // weird. The in message is actually taken from the output
+            // and the output is taken from the in
+
+            if (null != wsdl4jInputMessage) {
+                AxisMessage inMessage = axisOperation
+                        .getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
+                Message message = wsdl4jInputMessage.getMessage();
+                if (null != message) {
+
+                    inMessage.setName(message.getQName().getLocalPart());
+                    copyExtensionAttributes(wsdl4jInputMessage.getExtensionAttributes(),
+                                           inMessage, PORT_TYPE_OPERATION_OUTPUT);
+
+                }
+                // Check if the action is already set as we don't want to
+                // override it
+                // with the Default Action Pattern
+                String action = axisOperation.getOutputAction();
+                if (action == null) {
+                    action = WSDL11ActionHelper
+                            .getActionFromInputElement(dif, wsdl4jPortType,
+                                                       wsdl4jOperation, wsdl4jInputMessage);
+                }
+                if (action != null) {
+                    axisOperation.setOutputAction(action);
+                }
+            }
+            // Create an output message and add
+            Output wsdl4jOutputMessage = wsdl4jOperation.getOutput();
+            if (null != wsdl4jOutputMessage) {
+                AxisMessage outMessage = axisOperation
+                        .getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+                Message message = wsdl4jOutputMessage.getMessage();
+                if (null != message) {
+
+                    outMessage.setName(message.getQName().getLocalPart());
+                    copyExtensionAttributes(wsdl4jOutputMessage.getExtensionAttributes(),
+                                           outMessage, PORT_TYPE_OPERATION_INPUT);
+
+                    // wsdl:portType -> wsdl:operation -> wsdl:output
+                }
+                // Check if the action is already set as we don't want to
+                // override it
+                // with the Default Action Pattern
+                ArrayList inputActions = axisOperation.getWSAMappingList();
+                String action = null;
+                if (inputActions == null || inputActions.size() == 0) {
+                    action = WSDL11ActionHelper.getActionFromOutputElement(dif,
+                                                                           wsdl4jPortType,
+                                                                           wsdl4jOperation,
+                                                                           wsdl4jOutputMessage);
+                }
+                if (action != null) {
+                    if (inputActions == null) {
+                        inputActions = new ArrayList();
+                        axisOperation.setWsamappingList(inputActions);
+                    }
+                    inputActions.add(action);
+                }
+            }
+        }
+
+        Map faults = wsdl4jOperation.getFaults();
+        Iterator faultKeyIterator = faults.keySet().iterator();
+
+        while (faultKeyIterator.hasNext()) {
+            Fault fault = (Fault) faults.get(faultKeyIterator.next());
+            AxisMessage axisFaultMessage = new AxisMessage();
+            addDocumentation(axisFaultMessage,fault.getDocumentationElement());
+            Message faultMessage = fault.getMessage();
+            if (null != faultMessage) {
+                axisFaultMessage
+                        .setName(fault.getName());
+
+                copyExtensibleElements(faultMessage.getExtensibilityElements(),
+                                       dif, axisFaultMessage, PORT_TYPE_OPERATION_FAULT);
+
+            }
+
+            // Check if the action is already set as we don't want to override
+            // it
+            // with the Default Action Pattern
+            String action = axisOperation.getFaultAction(fault.getName());
+            if (action == null) {
+                action = WSDL11ActionHelper.getActionFromFaultElement(dif,
+                                                                      wsdl4jPortType,
+                                                                      wsdl4jOperation, fault);
+            }
+            if (action != null) {
+                axisOperation.addFaultAction(fault.getName(), action);
+            }
+
+            // Also add mapping from Exception name to fault action
+            String faultMessageName = axisFaultMessage.getName();
+            if (null != faultMessageName) {
+                char firstChar = faultMessageName.charAt(0);
+                String upperChar = String.valueOf(firstChar).toUpperCase();
+                String nameWithoutFirstChar = faultMessageName.substring(1);
+                String exceptionClassName = upperChar.concat(nameWithoutFirstChar);
+                if (log.isDebugEnabled()) {
+                    log.debug("Searching for fault action using faultMessageName = "+faultMessageName+", exceptionClassName = "+exceptionClassName);
+                }
+
+                String faultAction = axisOperation.getFaultAction(exceptionClassName);
+                if (faultAction == null) {
+                    faultAction = WSDL11ActionHelper.getActionFromFaultElement(dif,
+                                                                          wsdl4jPortType,
+                                                                          wsdl4jOperation, fault);
+                    if (log.isDebugEnabled()) {
+                        log.debug("Fault action didn't previously exist, getting it from WSDL: "+faultAction);
+                    }
+                }
+                if (faultAction != null) {
+                    axisOperation.addFaultAction(exceptionClassName, faultAction);
+                    axisOperation.addFaultAction(exceptionClassName+"_Exception", faultAction);
+                    if (log.isDebugEnabled()) {
+                        log.debug("Adding fault action entry: "+exceptionClassName+"="+faultAction);
+                        log.debug("Adding fault action entry: "+exceptionClassName+"_Exception"+"="+faultAction);
+                    }
+                }
+            }
+
+            axisOperation.setFaultMessages(axisFaultMessage);
+        }
+        return axisOperation;
+    }
+
+    /**
+     * Generates a list of wrapper schemas
+     *
+     * @param wsdl4jBinding
+     */
+    private Element[] generateWrapperSchema(Map schemaMap,
+                                            Binding wsdl4jBinding,
+                                            PortType portType) {
+
+        List schemaElementList = new ArrayList();
+        // target namespace for this should be the namespace URI for
+        // the porttype
+        String porttypeNamespaceURI = portType.getQName().getNamespaceURI();
+
+        // //////////////////////////////////////////////////////////////////////
+        // if there are any bindings present then we have to process them. we
+        // have to generate a schema per wsdl4jBinding (that is the safest
+        // option).
+        // if not we just resolve to
+        // the good old port type
+        // list, in which case we'll generate a schema per porttype
+        // //////////////////////////////////////////////////////////////////////
+
+        // findwrappable operations return either the rpc soap operations or
+        // Http binding operations
+
+        List wrappableBOEList = findWrappableBindingOperations(wsdl4jBinding);
+
+        // this method returns all the new schemas created when processing the rpc messages
+        Map newSchemaMap = createSchemaForPorttype(porttypeNamespaceURI,
+                                                   wrappableBOEList,
+                                                   schemaMap);
+
+        schemaElementList.addAll(newSchemaMap.values());
+        return (Element[]) schemaElementList
+                .toArray(new Element[schemaElementList.size()]);
+    }
+
+    /**
+     * Create a schema by looking at the port type
+     *
+     * @param namespaceURI - namespace of the porttype uri.
+     *  we use this only if a user has not specified a namespace in soap:body
+     * @param boeListToProcess - List of BindingOperationEntry objects which require wrappering
+     *
+     * @return null if there is no element
+     */
+    private Map createSchemaForPorttype(String namespaceURI,
+                                        List boeListToProcess,
+                                        Map existingSchemaMap) {
+
+        // this map is used to keep the newly added schemas
+        Map newSchemaMap = new HashMap();
+        // first of all look at the operations list
+        // we can return immediately if we get the operations list
+        // as empty
+        if (boeListToProcess.isEmpty()) {
+            return newSchemaMap;
+        }
+
+        // loop through the messages. We'll populate thins map with the relevant
+        // messages
+        // from the operations
+        Map messageQnameToMessageMap = new HashMap();
+        Map boeToInputMessageMap = new HashMap();
+        Map boeToOutputMessageMap = new HashMap();
+
+        // this contains the required namespace imports. the key in this
+        // map would be the namaspace URI
+        Map namespaceImportsMap = null;
+        // list namespace prefix map. This map will include uri -> prefix
+        Map namespacePrefixMap = null;
+
+        // //////////////////////////////////////////////////////////////////////////////////////////////////
+        // First thing is to populate the message map with the messages to
+        // process.
+        // //////////////////////////////////////////////////////////////////////////////////////////////////
+
+        // we really need to do this for a single porttype!
+        BindingOperationEntry boe;
+        for (int k = 0; k < boeListToProcess.size(); k++) {
+            boe = (BindingOperationEntry) boeListToProcess.get(k);
+            Input input = boe.getBindingOperation().getOperation().getInput();
+            Message message;
+            if (input != null) {
+                message = input.getMessage();
+                messageQnameToMessageMap.put(message.getQName(), message);
+                boeToInputMessageMap.put(boe, message);
+            }
+
+            Output output = boe.getBindingOperation().getOperation().getOutput();
+            if (output != null) {
+                message = output.getMessage();
+                messageQnameToMessageMap.put(message.getQName(), message);
+                boeToOutputMessageMap.put(boe, message);
+            }
+
+            // we do not want to process fault messages since they can only be used as document type
+            // see basic profile 4.4.2
+        }
+
+        // find the xsd prefix
+        String xsdPrefix = findSchemaPrefix();
+        // DOM document that will be the ultimate creator
+        Document document = getDOMDocumentBuilder().newDocument();
+
+        Element elementDeclaration;
+
+        //loop through the input op map and generate the elements
+        BindingOperationEntry boEntry;
+        for (Iterator boeIter = boeToInputMessageMap.keySet().iterator();
+             boeIter.hasNext();) {
+
+            boEntry = (BindingOperationEntry) boeIter.next();
+            elementDeclaration = document.createElementNS(
+                    XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
+                                             + XML_SCHEMA_ELEMENT_LOCAL_NAME);
+            elementDeclaration.setAttribute(XSD_NAME, boEntry.getBindingOperation().getName());
+
+            //when creating the inner complex type we have to find the parts list from the binding input
+            BindingInput bindingInput = boEntry.getBindingOperation().getBindingInput();
+            Message message = (Message) boeToInputMessageMap.get(boEntry);
+
+            if (bindingInput != null) {
+
+                Collection partsCollection = null;
+                if (BINDING_TYPE_SOAP.equals(this.bindingType)) {
+                    // first see the body parts list
+                    List bodyPartsList =
+                        getPartsListFromSoapBody(bindingInput.getExtensibilityElements());
+                    partsCollection = message.getOrderedParts(bodyPartsList);
+                } else {
+                    // i.e http binding
+                    partsCollection = message.getParts().values();
+                }
+
+                List parameterOrder =
+                   boEntry.getBindingOperation().getOperation().getParameterOrdering();
+                namespaceImportsMap = new HashMap();
+                namespacePrefixMap = new HashMap();
+
+                Node newComplexType = getNewComplextType(document,
+                                                         xsdPrefix,
+                                                         partsCollection,
+                                                         parameterOrder,
+                                                         false,
+                                                         namespaceImportsMap,
+                                                         namespacePrefixMap,
+                                                         boEntry);
+
+                elementDeclaration.appendChild(newComplexType);
+                String namespaceToUse = namespaceURI;
+
+                if (BINDING_TYPE_SOAP.equals(this.bindingType)) {
+                    String bodyNamespace =
+                            getNamespaceFromSoapBody(bindingInput.getExtensibilityElements());
+                    namespaceToUse = bodyNamespace != null ? bodyNamespace : namespaceURI;
+                }
+
+                if (existingSchemaMap.containsKey(namespaceToUse)) {
+                    // i.e this namespace is already exists with the original wsdl schemas
+                    addElementToAnExistingSchema((Element) existingSchemaMap.get(namespaceToUse),
+                                                 elementDeclaration,
+                                                 namespacePrefixMap,
+                                                 namespaceImportsMap,
+                                                 namespaceToUse);
+                } else if (newSchemaMap.containsKey(namespaceToUse)) {
+                    // i.e this namespace is with a newly created schema
+                    addElementToAnExistingSchema((Element) newSchemaMap.get(namespaceToUse),
+                                                 elementDeclaration,
+                                                 namespacePrefixMap,
+                                                 namespaceImportsMap,
+                                                 namespaceToUse);
+                } else {
+                    // i.e this element namespace has not found yet so
+                    // we have to create new schema for it
+                    Element newSchema = createNewSchemaWithElement(elementDeclaration,
+                                                                   namespacePrefixMap,
+                                                                   namespaceImportsMap,
+                                                                   namespaceToUse,
+                                                                   document,
+                                                                   xsdPrefix);
+                    newSchemaMap.put(namespaceToUse, newSchema);
+                }
+                resolvedRpcWrappedElementMap.put(boEntry.getBindingOperation().getName(), new QName(
+                        namespaceToUse, boEntry.getBindingOperation().getName(), AXIS2WRAPPED));
+
+            } else {
+                throw new WSDLProcessingException(
+                        "No binding input is defiend for binding operation ==> "
+                        + boEntry.getBindingOperation().getName());
+            }
+
+        }
+
+        // loop through the output to map and generate the elements
+        for (Iterator boeIterator = boeToOutputMessageMap.keySet().iterator();
+             boeIterator.hasNext();) {
+            boEntry = (BindingOperationEntry) boeIterator.next();
+            String baseoutputOpName = boEntry.getBindingOperation().getName();
+            // see basic profile 4.7.19
+            String outputOpName = baseoutputOpName + WRAPPED_OUTPUTNAME_SUFFIX;
+            elementDeclaration = document.createElementNS(
+                    XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
+                                             + XML_SCHEMA_ELEMENT_LOCAL_NAME);
+            elementDeclaration.setAttribute(XSD_NAME, outputOpName);
+
+            BindingOutput bindingOutput = boEntry.getBindingOperation().getBindingOutput();
+            Message message = (Message) boeToOutputMessageMap.get(boEntry);
+
+            if (bindingOutput != null) {
+                Collection partsCollection = null;
+                if (BINDING_TYPE_SOAP.equals(this.bindingType)) {
+                    // first see the body parts list
+                    List bodyPartsList =
+                        getPartsListFromSoapBody(bindingOutput.getExtensibilityElements());
+                    partsCollection = message.getOrderedParts(bodyPartsList);
+
+                } else {
+                    // i.e if http binding
+                    partsCollection = message.getParts().values();
+                }
+
+                List parameterOrder =
+                    boEntry.getBindingOperation().getOperation().getParameterOrdering();
+
+                // we have to initialize the hash maps always since we add the elements onece we
+                // generate it
+                namespacePrefixMap = new HashMap();
+                namespaceImportsMap = new HashMap();
+
+                Node newComplexType = getNewComplextType(document,
+                                                         xsdPrefix,
+                                                         partsCollection,
+                                                         parameterOrder,
+                                                         true,
+                                                         namespaceImportsMap,
+                                                         namespacePrefixMap,
+                                                         boEntry);
+                elementDeclaration.appendChild(newComplexType);
+
+                String namespaceToUse = namespaceURI;
+
+                if (BINDING_TYPE_SOAP.equals(this.bindingType)) {
+                    String bodyNamespace =
+                            getNamespaceFromSoapBody(bindingOutput.getExtensibilityElements());
+                    namespaceToUse = bodyNamespace != null ? bodyNamespace : namespaceURI;
+                }
+
+                if (existingSchemaMap.containsKey(namespaceToUse)) {
+                    // i.e this namespace is already exists with the original wsdl schemas
+                    addElementToAnExistingSchema((Element) existingSchemaMap.get(namespaceToUse),
+                                                 elementDeclaration,
+                                                 namespacePrefixMap,
+                                                 namespaceImportsMap,
+                                                 namespaceToUse);
+                } else if (newSchemaMap.containsKey(namespaceToUse)) {
+                    // i.e this namespace is with a newly created schema
+                    addElementToAnExistingSchema((Element) newSchemaMap.get(namespaceToUse),
+                                                 elementDeclaration,
+                                                 namespacePrefixMap,
+                                                 namespaceImportsMap,
+                                                 namespaceToUse);
+                } else {
+                    // i.e this element namespace has not found yet so
+                    // we have to create new schema for it
+                    Element newSchema = createNewSchemaWithElement(elementDeclaration,
+                                                                   namespacePrefixMap,
+                                                                   namespaceImportsMap,
+                                                                   namespaceToUse,
+                                                                   document,
+                                                                   xsdPrefix);
+                    newSchemaMap.put(namespaceToUse, newSchema);
+                }
+                resolvedRpcWrappedElementMap.put(outputOpName, new QName(
+                        namespaceToUse, outputOpName, AXIS2WRAPPED));
+
+            } else {
+                throw new WSDLProcessingException(
+                        "No binding out put is defined for binding operation ==>" +
+                        boEntry.getBindingOperation().getName());
+            }
+        }
+
+        return newSchemaMap;
+    }
+
+    private void addElementToAnExistingSchema(Element schemaElement,
+                                              Element newElement,
+                                              Map namespacePrefixMap,
+                                              Map namespaceImportsMap,
+                                              String targetNamespace) {
+
+        Document ownerDocument = schemaElement.getOwnerDocument();
+
+        String newElementName = newElement.getAttribute(XSD_NAME);
+
+        // check whether this element already exists.
+        NodeList nodeList = schemaElement.getChildNodes();
+        Element nodeElement = null;
+        for (int i = 1; i < nodeList.getLength(); i++) {
+            if (nodeList.item(i) instanceof Element){
+                nodeElement = (Element) nodeList.item(i);
+                if (nodeElement.getLocalName().equals(XML_SCHEMA_ELEMENT_LOCAL_NAME)){
+                    if (nodeElement.getAttribute(XSD_NAME).equals(newElementName)){
+                        // if the element already exists we do not add this element
+                        // and just return.
+                        return;
+                    }
+                }
+            }
+
+        }
+
+        // loop through the namespace declarations first and add them
+        String[] nameSpaceDeclarationArray = (String[]) namespacePrefixMap
+                .keySet().toArray(new String[namespacePrefixMap.size()]);
+        for (int i = 0; i < nameSpaceDeclarationArray.length; i++) {
+            String s = nameSpaceDeclarationArray[i];
+            checkAndAddNamespaceDeclarations(s, namespacePrefixMap,
+                                             schemaElement);
+        }
+
+        // add imports - check whether it is the targetnamespace before
+        // adding
+        Element[] namespaceImports = (Element[]) namespaceImportsMap
+                .values().toArray(new Element[namespaceImportsMap.size()]);
+        for (int i = 0; i < namespaceImports.length; i++) {

[... 1436 lines stripped ...]


Mime
View raw message