Copy 1.x trunk to branches for start of 1.6 release

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@892786 13f79535-47bb-0310-9956-ffa450edef68

9 files changed, 1722 insertions, 0 deletions

diff --git a/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/JavaInterfaceEmitter.java b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/JavaInterfaceEmitter.java
new file mode 100644
index 0000000000..08c7131208
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/JavaInterfaceEmitter.java
@@ -0,0 +1,224 @@
+/*
+ * 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.tuscany.tools.wsdl2java.generate;
+
+import static org.apache.tuscany.tools.wsdl2java.util.XMLNameUtil.getJavaNameFromXMLName;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.namespace.QName;
+
+import org.apache.axis2.description.AxisBindingOperation;
+import org.apache.axis2.description.AxisMessage;
+import org.apache.axis2.description.AxisOperation;
+import org.apache.axis2.util.FileWriter;
+import org.apache.axis2.wsdl.WSDLConstants;
+import org.apache.axis2.wsdl.codegen.CodeGenConfiguration;
+import org.apache.axis2.wsdl.codegen.emitter.JavaEmitter;
+import org.apache.axis2.wsdl.codegen.writer.InterfaceWriter;
+import org.apache.axis2.wsdl.databinding.TypeMapper;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+/**
+ * Overrides the Axis2 JavaEmitter to generate unwrapped methods.
+ */
+public class JavaInterfaceEmitter extends JavaEmitter {
+
+    private CodeGenConfiguration codegenConfiguration;
+    private TypeMapper typeMapper;
+
+    @Override
+    public void setCodeGenConfiguration(CodeGenConfiguration configuration) {
+        super.setCodeGenConfiguration(configuration);
+        codegenConfiguration = configuration;
+    }
+
+    @Override
+    public void setMapper(TypeMapper typeMapper) {
+        super.setMapper(typeMapper);
+        this.typeMapper = typeMapper;
+    }
+
+    private List getParameterElementList(Document doc, AxisMessage message, boolean wrapped) {
+        List parameterElementList = new ArrayList();
+
+        if (message != null && message.getElementQName() != null) {
+
+            SDODataBindingTypeMappingEntry typeMappingEntry =
+                (SDODataBindingTypeMappingEntry)this.typeMapper.getTypeMappingObject(message.getElementQName());
+            List typeMappings;
+            if (wrapped) {
+                typeMappings = typeMappingEntry.getPropertyClassNames();
+                if(typeMappings == null) {
+                    typeMappings = new ArrayList();
+                    typeMappings.add(typeMappingEntry.getClassName());
+                }
+            } else {
+                typeMappings = new ArrayList();
+                typeMappings.add(typeMappingEntry.getClassName());
+            }
+
+            for (int i = 0; i < typeMappings.size(); i++) {
+                Element param = doc.createElement("param");
+                parameterElementList.add(param);
+
+                String typeMapping = (String)typeMappings.get(i);
+
+                addAttribute(doc, "name", this.typeMapper.getParameterName(message.getElementQName()), param);
+                addAttribute(doc, "type", (typeMapping == null) ? "" : typeMapping, param);
+
+                // add an extra attribute to say whether the type mapping is the
+                // default
+                // if (TypeMapper.DEFAULT_CLASS_NAME.equals(typeMapping)) {
+                if (typeMapper.getDefaultMappingName().equals(typeMapping)) {
+
+                    addAttribute(doc, "default", "yes", param);
+                }
+
+                addAttribute(doc, "value", null, param);
+
+                // add this as a body parameter
+                addAttribute(doc, "location", "body", param);
+
+            }
+        }
+
+        return parameterElementList;
+    }
+
+    @Override
+    public List getParameterElementList(Document doc, List parameters, String location) {
+        List parameterElementList = new ArrayList();
+
+        if ((parameters != null) && !parameters.isEmpty()) {
+            int count = parameters.size();
+
+            for (int i = 0; i < count; i++) {
+                Element param = doc.createElement("param");
+                QName name = (QName)parameters.get(i);
+
+                addAttribute(doc, "name", this.typeMapper.getParameterName(name), param);
+
+                String typeMapping = this.typeMapper.getTypeMappingName(name);
+                String typeMappingStr = (typeMapping == null) ? "" : typeMapping;
+
+                addAttribute(doc, "type", typeMappingStr, param);
+                addAttribute(doc, "location", location, param);
+                parameterElementList.add(param);
+            }
+        }
+
+        return parameterElementList;
+    }
+
+    @Override
+    protected Element getInputElement(Document doc, AxisBindingOperation operation, List headerParameterQNameList) {
+        return getElement(doc,
+                          "input",
+                          operation.getAxisOperation().getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE),
+                          operation.getAxisOperation().getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE).isWrapped(),
+                          headerParameterQNameList);
+    }
+
+    @Override
+    protected Element getOutputElement(Document doc, AxisBindingOperation operation, List headerParameterQNameList) {
+        return getElement(doc,
+                          "output",
+                          operation.getAxisOperation().getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE),
+                          operation.getAxisOperation().getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE).isWrapped(),
+                          headerParameterQNameList);
+    }
+
+    protected Element getElement(Document doc,
+                                 String elementName,
+                                 AxisMessage message,
+                                 boolean wrapped,
+                                 List headerParameterQNameList) {
+        Element element = doc.createElement(elementName);
+
+        List parameterElementList = getParameterElementList(doc, message, wrapped);
+        for (int i = 0; i < parameterElementList.size(); i++) {
+            element.appendChild((Element)parameterElementList.get(i));
+        }
+
+        List outputElementList = getParameterElementList(doc, headerParameterQNameList, "header");
+
+        for (int i = 0; i < outputElementList.size(); i++) {
+            element.appendChild((Element)outputElementList.get(i));
+        }
+
+        return element;
+    }
+
+    @Override
+    protected void writeInterface(boolean writeDatabinders) throws Exception {
+        Document interfaceModel = createDOMDocumentForInterface(writeDatabinders);
+        if (!codegenConfiguration.getOutputLocation().exists()) {
+            codegenConfiguration.getOutputLocation().mkdirs();
+        }
+        InterfaceWriter interfaceWriter =
+            new RemotableInterfaceWritter(this.codegenConfiguration.getOutputLocation(), this.codegenConfiguration
+                .getOutputLanguage());
+
+        String packageName = interfaceModel.getDocumentElement().getAttribute("package");
+        String className = interfaceModel.getDocumentElement().getAttribute("name");
+
+        System.out.println(">>  Generating Java class " + packageName + "." + className);
+        File outputFile =
+            FileWriter.createClassFile(this.codegenConfiguration.getOutputLocation(), packageName, className, ".java");
+        if (outputFile.exists()) {
+            outputFile.delete();
+        }
+
+//      JIRA TUSCANY-1561 Port to Axis2 1.3                
+//        writeClass(interfaceModel, interfaceWriter);
+
+        writeFile(interfaceModel, interfaceWriter);
+    }
+
+    @Override
+    protected String makeJavaClassName(String word) {
+        // return XMLNameUtil.getJavaNameFromXMLName(word, true);
+        return getJavaNameFromXMLName(word, true);
+    }
+
+    @Override
+    protected Element[] getFaultParamElements(Document doc, AxisOperation operation) {
+        ArrayList params = new ArrayList();
+        ArrayList faultMessages = operation.getFaultMessages();
+
+        if (faultMessages != null && !faultMessages.isEmpty()) {
+            Element paramElement;
+            AxisMessage msg;
+            for (int i = 0; i < faultMessages.size(); i++) {
+                paramElement = doc.createElement("param");
+                msg = (AxisMessage)faultMessages.get(i);
+                String msgClassName = WSDL2JavaGenerator.normalizeClassName(msg.getName());
+                addAttribute(doc, "name", msgClassName, paramElement);
+                params.add(paramElement);
+            }
+
+            return (Element[])params.toArray(new Element[params.size()]);
+        } else {
+            return new Element[] {};// return empty array
+        }
+    }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/JavaInterfaceGenerator.java b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/JavaInterfaceGenerator.java
new file mode 100644
index 0000000000..8e0c3683a3
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/JavaInterfaceGenerator.java
@@ -0,0 +1,327 @@
+/*
+ * 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.tuscany.tools.wsdl2java.generate;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import javax.wsdl.Binding;
+import javax.wsdl.Definition;
+import javax.wsdl.Fault;
+import javax.wsdl.Message;
+import javax.wsdl.Operation;
+import javax.wsdl.Part;
+import javax.wsdl.Port;
+import javax.wsdl.PortType;
+import javax.wsdl.Service;
+import javax.wsdl.WSDLException;
+import javax.wsdl.factory.WSDLFactory;
+import javax.wsdl.xml.WSDLReader;
+import javax.xml.namespace.QName;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.apache.axis2.AxisFault;
+import org.apache.axis2.description.AxisService;
+import org.apache.axis2.description.WSDL11ToAxisServiceBuilder;
+import org.apache.axis2.util.FileWriter;
+import org.apache.axis2.util.XMLUtils;
+import org.apache.axis2.wsdl.codegen.CodeGenConfiguration;
+import org.apache.axis2.wsdl.codegen.CodeGenerationException;
+import org.apache.axis2.wsdl.codegen.extension.CodeGenExtension;
+import org.apache.axis2.wsdl.codegen.extension.DefaultDatabindingExtension;
+import org.apache.axis2.wsdl.codegen.extension.PackageFinder;
+import org.apache.axis2.wsdl.codegen.extension.WSDLValidatorExtension;
+import org.apache.axis2.wsdl.databinding.JavaTypeMapper;
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
+
+import com.sun.tools.xjc.api.XJC;
+
+public class JavaInterfaceGenerator {
+
+    private List codegenExtensions = new ArrayList();
+    private List<CodeGenConfiguration> codegenConfigurations= new LinkedList<CodeGenConfiguration>();
+    private String outputLocation;
+    
+
+
+    public JavaInterfaceGenerator(String uri, String ports[], String outputLocation, String packageName,
+                                  Map<QName, SDODataBindingTypeMappingEntry> typeMapping) throws CodeGenerationException {
+        this.outputLocation = outputLocation;
+        
+        Definition definition;
+        try {
+            definition = readWSDL(uri);
+        } catch (WSDLException e) {
+            throw new CodeGenerationException(e);
+        }
+        
+        HashSet<String> interestedPorts = ports == null ? null : new HashSet<String>(Arrays.asList(ports));
+        
+       // Service service=(Service)definition.getServices().values().().next();
+        
+        HashSet<QName> donePortTypes= new HashSet<QName>();
+        
+        for (Iterator sIter  = definition.getServices().values().iterator(); sIter.hasNext(); ) {
+            Service service = (Service) sIter.next();
+            
+            QName serviceQname = service.getQName();
+             for (Iterator pIter= service.getPorts().values().iterator(); pIter.hasNext(); ) {
+                 Port port= (Port) pIter.next();
+                if(interestedPorts != null && ! interestedPorts.contains(port.getName())) continue;//not iterested.
+                 PortType portType= getPortType(port);
+                 if(null == portType) continue; // not connected.
+                 QName pQName= portType.getQName();
+                 if(donePortTypes.contains(pQName)) continue; //allready did it.
+                 donePortTypes.add(pQName);
+              
+                if (packageName == null) {
+                    //use JAXWS/JAXB NS->package default algorithm, not the SDO/EMF one
+                    packageName = XJC.getDefaultPackageName(definition.getTargetNamespace());
+                }
+                //
+                // Use WSDL4J object to generate exception classes
+                //
+                generateFaults(packageName, portType, typeMapping);
+                JavaTypeMapper typeMapper = new JavaTypeMapper();
+                for (Map.Entry<QName, SDODataBindingTypeMappingEntry> e : typeMapping.entrySet()) {
+                    typeMapper.addTypeMappingObject(e.getKey(), e.getValue());
+                    // Added for generation of exceptions from faults
+                    typeMapper.addTypeMappingName(e.getKey(), e.getValue().getClassName());
+                }
+
+
+                AxisService axisService;
+                WSDL11ToAxisServiceBuilder builder;
+                try {
+                    //
+                    // Added since at a newer level of Axis2, this doesn't work 
+                    //  without the setCodegen(true)
+                    //
+                    builder = new WSDL11ToAxisServiceBuilder(definition, serviceQname, port.getName());
+                    builder.setCodegen(true);
+                    axisService = builder.populateService();
+                } catch (AxisFault e) {
+                    throw new CodeGenerationException(e);
+                }
+
+                axisService.setName(port.getBinding().getPortType().getQName().getLocalPart());
+                CodeGenConfiguration codegenConfiguration = new CodeGenConfiguration(Collections.EMPTY_MAP);
+                codegenConfigurations.add(codegenConfiguration);
+                codegenConfiguration.setAxisService(axisService);
+                codegenConfiguration.setAdvancedCodeGenEnabled(false);
+                codegenConfiguration.setAsyncOn(false);
+                codegenConfiguration.setDatabindingType("sdo");
+                codegenConfiguration.setGenerateAll(true);
+                codegenConfiguration.setGenerateDeployementDescriptor(false);
+                codegenConfiguration.setOutputLanguage("java");
+                codegenConfiguration.setOutputLocation(new File(outputLocation));
+                codegenConfiguration.setPackageName(packageName);
+                codegenConfiguration.setPackClasses(false);
+                codegenConfiguration.setPolicyMap(Collections.EMPTY_MAP);
+                codegenConfiguration.setPortName(port.getName());
+                codegenConfiguration.setServerSide(false);
+                codegenConfiguration.setServiceName(service.getQName().getLocalPart());
+                // This lines up with the sync/async variable from the XSL template
+                codegenConfiguration.setSyncOn(true);
+                codegenConfiguration.setTypeMapper(typeMapper);
+
+// JIRA TUSCANY-1561 Port to Axis2 1.3                
+//                codegenConfiguration.setWriteMessageReceiver(false);
+                codegenConfiguration.setSkipMessageReceiver(true);
+                
+                codegenConfiguration.setWriteTestCase(false);
+                addExtension(new WSDLValidatorExtension(), codegenConfiguration);
+                addExtension(new PackageFinder(), codegenConfiguration);
+                addExtension(new SDODataBindingCodegenExtension(typeMapper), codegenConfiguration);
+                addExtension(new DefaultDatabindingExtension(), codegenConfiguration);
+            }            
+        }        
+    }
+
+
+    private PortType getPortType(Port port) {
+       Binding binding = port.getBinding();
+       if(null != binding){
+          return binding.getPortType();
+       }
+       return null;
+        
+    }
+
+
+    @SuppressWarnings("unchecked")
+    private void addExtension(CodeGenExtension ext, CodeGenConfiguration codegenConfiguration) {
+        //ext.init(codegenConfiguration);
+        codegenExtensions.add(new Object[]{ext, codegenConfiguration});
+    }
+
+    public void generate() throws CodeGenerationException {
+        try {
+            for (int i = 0; i < codegenExtensions.size(); i++) {
+                // CodeGenExtension
+                Object[] pair = (Object[])codegenExtensions.get(i);
+
+                CodeGenExtension cge = (CodeGenExtension)pair[0];
+                CodeGenConfiguration cgf = (CodeGenConfiguration)pair[1];
+
+                cge.engage(cgf);
+            }
+
+            for (CodeGenConfiguration codegenConfiguration : codegenConfigurations) {
+                JavaInterfaceEmitter emitter = new JavaInterfaceEmitter();
+                emitter.setCodeGenConfiguration(codegenConfiguration);
+                emitter.setMapper(codegenConfiguration.getTypeMapper());
+
+                emitter.writeInterface(false);
+            }
+
+        } catch (Exception e) {
+            throw new CodeGenerationException(e);
+        }
+    }
+
+    /**
+     * Read the WSDL file
+     * 
+     * @param uri
+     * @return
+     * @throws WSDLException
+     */
+    private Definition readWSDL(String uri) throws WSDLException {
+
+        WSDLReader reader = WSDLFactory.newInstance().newWSDLReader();
+        reader.setFeature("javax.wsdl.importDocuments", true);
+
+        File file = new File(uri);
+        String baseURI;
+
+        if (uri.startsWith("http://")) {
+            baseURI = uri;
+        } else {
+            if (file.getParentFile() == null) {
+                try {
+                    baseURI = new File(".").getCanonicalFile().toURI().toString();
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            } else {
+                baseURI = file.getParentFile().toURI().toString();
+            }
+        }
+
+        Document doc;
+        try {
+            doc = XMLUtils.newDocument(uri);
+        } catch (ParserConfigurationException e) {
+            throw new WSDLException(WSDLException.PARSER_ERROR, "Parser Configuration Error", e);
+        } catch (SAXException e) {
+            throw new WSDLException(WSDLException.PARSER_ERROR, "Parser SAX Error", e);
+
+        } catch (IOException e) {
+            throw new WSDLException(WSDLException.INVALID_WSDL, "IO Error", e);
+        }
+
+        return reader.readWSDL(baseURI, doc);
+    }
+    
+    private void generateFaults(String packageName, PortType portType, Map<QName, SDODataBindingTypeMappingEntry> typeMapping) 
+        throws CodeGenerationException{
+        
+        for (Object o: portType.getOperations()) {
+            Operation op = (Operation)o;
+            Map messageMap = op.getFaults();
+            Iterator iter = messageMap.values().iterator();
+            while (iter.hasNext()) {
+                Fault fault = (Fault)iter.next();
+                Message faultMsg = fault.getMessage();
+                Iterator iter2 = faultMsg.getParts().values().iterator();
+                Part faultMsgPart = (Part)iter2.next();
+                // TODO - if other parts throw exc
+                QName faultMsgQName = faultMsg.getQName();
+                QName faultMsgPartElementQName = faultMsgPart.getElementName();
+                String faultClassName = typeMapping.get(faultMsgPartElementQName).getClassName();                
+                writeException(packageName, faultMsgQName, faultClassName, faultMsgPartElementQName);
+            }
+        }
+    }
+    
+    private void writeException(String packageName, QName faultMsgQName, String faultClassName, QName faultMsgPartElementQName) 
+        throws CodeGenerationException{        
+        
+        try {
+            String faultWrapperClassName = 
+                WSDL2JavaGenerator.normalizeClassName(faultMsgQName.getLocalPart());
+            
+            File outputDir = new File(this.outputLocation);
+            
+            if (!outputDir.exists()) {
+                outputDir.mkdirs();
+            }
+            File outputFile = FileWriter.createClassFile(outputDir,
+                    packageName, faultWrapperClassName, ".java");
+
+            FileOutputStream fileStream = new FileOutputStream(outputFile);       
+            PrintStream stream = new PrintStream(fileStream); 
+
+            System.out.println(">>  Generating Java exception class " + packageName + "." + faultWrapperClassName);
+
+            stream.println();
+            stream.println("package " + packageName + ";");
+            stream.println();
+            stream.println("import javax.xml.ws.WebFault;");
+            stream.println();
+            stream.println("@WebFault(name=\"" + faultMsgPartElementQName.getLocalPart()
+                + "\", targetNamespace=\""
+                + faultMsgPartElementQName.getNamespaceURI()
+                + "\")");
+            stream.println("public class " + faultWrapperClassName  + " extends Exception {");
+            stream.println();
+            stream.println("    private " + faultClassName + " fault;");
+            stream.println();
+            stream.println("    public " + faultWrapperClassName + "(String message, " + faultClassName + " fault) {");
+            stream.println("        super(message);");
+            stream.println("        this.fault = fault;");
+            stream.println("    }");
+            stream.println();
+            stream.println("    public " + faultWrapperClassName + "(String message, " + faultClassName + " fault, Throwable cause) {");
+            stream.println("        super(message, cause);");
+            stream.println("        this.fault = fault;");
+            stream.println("    }");
+            stream.println();
+            stream.println("    public " + faultClassName + " getFaultInfo() {");
+            stream.println("        return this.fault;");
+            stream.println("    }");
+            stream.println("}");
+            stream.println();
+        } catch (Exception e) {
+            throw new CodeGenerationException(e);
+        }
+    }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/RemotableInterfaceWritter.java b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/RemotableInterfaceWritter.java
new file mode 100644
index 0000000000..0c4f42633a
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/RemotableInterfaceWritter.java
@@ -0,0 +1,53 @@
+/*
+ * 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.tuscany.tools.wsdl2java.generate;
+
+import java.io.File;
+
+import org.apache.axis2.wsdl.codegen.CodeGenerationException;
+import org.apache.axis2.wsdl.codegen.writer.InterfaceWriter;
+
+/**
+ *
+ */
+public class RemotableInterfaceWritter extends InterfaceWriter {
+    private static final String REMOTABLE_INTERFACE_TEMPLATE="/RemotableInterfaceTemplate.xsl";
+
+    public RemotableInterfaceWritter(String outputFileLocation) {
+        super(outputFileLocation);
+    }
+
+    public RemotableInterfaceWritter(File outputFileLocation, String language) {
+        super(outputFileLocation, language);
+    }
+
+    /**
+     * Loads the template.
+     */
+    @Override
+    public void loadTemplate() throws CodeGenerationException {
+        // the default behavior for the class writers is to use the property map from the language specific types
+        // The properties are arranged in the following order
+        // <lang-name>.* .template=<write-class>,<template-name>
+
+        //override original behaviour to always load the template we specified
+        this.xsltStream = this.getClass().getResourceAsStream(REMOTABLE_INTERFACE_TEMPLATE);
+
+    }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/SDODataBindingCodegenExtension.java b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/SDODataBindingCodegenExtension.java
new file mode 100644
index 0000000000..4ab152fb90
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/SDODataBindingCodegenExtension.java
@@ -0,0 +1,63 @@
+/*
+ * 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.tuscany.tools.wsdl2java.generate;
+
+import org.apache.axis2.wsdl.codegen.CodeGenConfiguration;
+import org.apache.axis2.wsdl.codegen.CodeGenerationException;
+import org.apache.axis2.wsdl.codegen.extension.AbstractDBProcessingExtension;
+import org.apache.axis2.wsdl.databinding.TypeMapper;
+
+/**
+ * SDO data binding codegen extension.
+ */
+public class SDODataBindingCodegenExtension extends AbstractDBProcessingExtension {
+
+    private TypeMapper typeMapper;
+    
+    public SDODataBindingCodegenExtension(TypeMapper typeMapper) {
+        this.typeMapper=typeMapper;
+    }
+    
+    @Override
+    protected boolean testFallThrough(String dbFrameworkName) {
+        return !dbFrameworkName.equals("sdo");
+    }
+
+//    public void engage() {
+//        if (testFallThrough(configuration.getDatabindingType())) {
+//            return;
+//        }
+//        
+//        // Set the type mapper into the config
+//        configuration.setTypeMapper(typeMapper);
+//
+//    }
+
+    public void engage(CodeGenConfiguration configuration) throws CodeGenerationException {
+        if (testFallThrough(configuration.getDatabindingType())) {
+            return;
+        }
+        
+        // Set the type mapper into the config
+        configuration.setTypeMapper(typeMapper);
+
+        
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/SDODataBindingTypeMappingEntry.java b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/SDODataBindingTypeMappingEntry.java
new file mode 100644
index 0000000000..2d81ef12bf
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/SDODataBindingTypeMappingEntry.java
@@ -0,0 +1,51 @@
+/*
+ * 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.tuscany.tools.wsdl2java.generate;
+
+import java.util.List;
+
+/**
+ * This represents a type mapping entry, used by the JavaInterfaceEmitter to generate
+ * method signatures.  
+ */
+public class SDODataBindingTypeMappingEntry {
+
+    private final boolean anonymous;
+    private final List<String> propertyClassNames;
+    private final String className;
+
+    public SDODataBindingTypeMappingEntry(String className, boolean anonymous, List<String> propertyClassNames) {
+        this.className = className;
+        this.anonymous = anonymous;
+        this.propertyClassNames = propertyClassNames;
+    }
+
+    public boolean isAnonymous() {
+        return anonymous;
+    }
+
+    public String getClassName() {
+        return className;
+    }
+
+    public List<String> getPropertyClassNames() {
+        return propertyClassNames;
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/WSDL2JavaGenerator.java b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/WSDL2JavaGenerator.java
new file mode 100644
index 0000000000..f6d1f3a64a
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/generate/WSDL2JavaGenerator.java
@@ -0,0 +1,529 @@
+/*
+ * 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.tuscany.tools.wsdl2java.generate;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+import javax.xml.namespace.QName;
+
+import org.apache.tuscany.sdo.generate.XSD2JavaGenerator;
+import org.apache.tuscany.sdo.helper.HelperContextImpl;
+import org.apache.tuscany.sdo.util.DataObjectUtil;
+import org.eclipse.emf.codegen.ecore.genmodel.GenClass;
+import org.eclipse.emf.codegen.ecore.genmodel.GenModel;
+import org.eclipse.emf.codegen.ecore.genmodel.GenModelFactory;
+import org.eclipse.emf.codegen.ecore.genmodel.GenPackage;
+import org.eclipse.emf.codegen.util.CodeGenUtil;
+import org.eclipse.emf.common.util.Diagnostic;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.impl.EPackageRegistryImpl;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.util.BasicExtendedMetaData;
+import org.eclipse.emf.ecore.util.ExtendedMetaData;
+
+import commonj.sdo.helper.HelperContext;
+import commonj.sdo.helper.XSDHelper;
+
+public class WSDL2JavaGenerator {
+    //Note: Dynamic SDO is defined as 0x4000 to avoid conflict with XSD2Java genOptions
+    static protected final int DYNAMIC_SDO = 0x1;
+    static protected final int GENERATE_SDO = 0x2;
+    static protected final int VERBOSE_MODE = 0x4;
+    static protected final String NO_GEN_PARM = "-noGenerate";
+    static protected final String TARGET_DIR_PARM = "-targetDirectory";
+    static protected final String JAVA_PACKAGE_PARM = "-javaPackage";
+    static protected final String ALL_NAMESPACES_PARM = "-schemaNamespace all";
+
+    /**
+     * Generate Java interfaces from WSDL Usage arguments: [ -targetDirectory
+     * <target-root-directory> ] [ -javaPackage <java-package-name> ]
+     * <wsdl-file> For example: generate somedir/somefile.wsdl Basic options:
+     * -targetDirectory Generates the Java source code in the specified
+     * directory. By default, the code is generated in the same directory as the
+     * input WSDL file. -javaPackage Overrides the Java package for the
+     * generated classes. By default the package name is derived from the
+     * targetNamespace of the WSDL definition being generated. For example, if
+     * the targetNamespace is "http://www.example.com/simple", the default
+     * package will be "com.example.simple".
+     */
+    public static void main(String args[]) {
+        if (args.length == 0) {
+            printUsage();
+            return;
+        }
+
+        String portName = null;
+        String targetDirectory = null;
+        String wsdlJavaPackage = null;
+        String xsdJavaPackage = null;
+        String sdoGenArgs = null;
+        String sdoGenArgsString = null;
+        int genOptions = 0;
+
+        int index = 0;
+        for (; index < args.length && args[index].startsWith("-"); ++index) {
+            if (args[index].equalsIgnoreCase("-port")) {
+                portName = args[++index];
+            } else if (args[index].equalsIgnoreCase("-targetDirectory")) {
+                targetDirectory = args[++index];
+            } else if (args[index].equalsIgnoreCase("-javaPackage")) {
+                wsdlJavaPackage = args[++index];
+            } else if (args[index].equalsIgnoreCase("-dynamicSDO")) {
+                genOptions |= DYNAMIC_SDO;
+            } else if (args[index].equalsIgnoreCase("-generateSDO")){
+                genOptions |= GENERATE_SDO;
+            } else if (args[index].equalsIgnoreCase("-sdoGenArgs")){
+                sdoGenArgs = args[++index];
+            } else if (args[index].equalsIgnoreCase("-verbose")){
+               genOptions |= VERBOSE_MODE; 
+            }
+            // else if (...)
+            else {
+                printUsage();
+                return;
+            }
+        }
+        if (sdoGenArgs!=null && (GENERATE_SDO & genOptions)== 0){
+            genOptions |= GENERATE_SDO;
+        }
+        
+        if (targetDirectory == null) {
+            targetDirectory = ".";
+        }
+        String wsdlFileName = args[index];
+        if (wsdlFileName == null || ((DYNAMIC_SDO & genOptions)!=0 && (GENERATE_SDO & genOptions)!= 0)) {
+            printUsage();
+            return;
+        }
+        if (sdoGenArgs !=null){
+            try {
+                    File inFile = new File(sdoGenArgs).getAbsoluteFile();
+                    FileReader inputFile = new FileReader(inFile);
+                    BufferedReader bufRead = new BufferedReader(inputFile);
+                    StringBuffer fileContents= new StringBuffer();
+                    String line;
+                    while ((line = bufRead.readLine())!=null){
+                        fileContents.append(line + " ");
+                    }
+                    sdoGenArgsString = fileContents.toString();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    throw new IllegalArgumentException(e);
+                }
+        } else {
+                sdoGenArgsString = null;
+        }
+        
+        if ((DYNAMIC_SDO & genOptions) != 0){
+            generateDynamicFromWSDL(wsdlFileName, portName!=null? new String[]{portName}:null, targetDirectory, wsdlJavaPackage, xsdJavaPackage, genOptions);
+        } else {
+            generateFromWSDL(wsdlFileName, portName!=null? new String[]{portName}:null, targetDirectory, wsdlJavaPackage, genOptions, sdoGenArgsString);   
+        }
+        
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static void generateFromWSDL(String wsdlFileName, String[] ports, String targetDirectory, String wsdlJavaPackage, int genOptions, String sdoGenArgsString)
+    {
+        try {        
+                if (targetDirectory == null) {
+                    targetDirectory = new File(wsdlFileName).getCanonicalFile().getParent();
+                } else {
+                    targetDirectory = new File(targetDirectory).getCanonicalPath();
+                }
+                          
+                // Populate the typeMapping table that will be given to the Axis2 WSDL2Java 
+                Map<QName, SDODataBindingTypeMappingEntry> typeMapping =
+                                        new HashMap<QName, SDODataBindingTypeMappingEntry>();
+                StringBuffer buildCommand = new StringBuffer();
+                //build XSD command lines
+                //build generic command for simple case & dynamic SDO
+                buildCommand.append(ALL_NAMESPACES_PARM);
+                if (sdoGenArgsString == null){
+                     buildCommand.append(" " + TARGET_DIR_PARM + " " + targetDirectory);
+                     if (wsdlJavaPackage != null && (genOptions & GENERATE_SDO)!=0){
+                         buildCommand.append(" " + JAVA_PACKAGE_PARM + " " + wsdlJavaPackage);
+                     }
+                     if ((genOptions & GENERATE_SDO)==0){
+                          buildCommand.append(" ");
+                          buildCommand.append(NO_GEN_PARM);        
+                     }
+                } else {
+                    buildCommand.append(" ");
+                    buildCommand.append(sdoGenArgsString);
+                }
+                
+                //TUSCANY-1642 - We shouldn't split the wsdlFileName as it my contain a filename with spaces
+                Vector sdoCommand = new Vector(java.util.Arrays.asList(buildCommand.toString().split("\\s+")));
+                sdoCommand.add(wsdlFileName);
+
+                String[] sdoGenCommand = new String[sdoCommand.size()];
+                sdoCommand.toArray(sdoGenCommand);  
+                
+                if ((genOptions & VERBOSE_MODE)!=0){
+                        System.out.println("Options passed to XSD2Java: ");
+                        for (int i=0; i<sdoGenCommand.length; i++){ System.out.println("\"" + sdoGenCommand[i] + "\"");}        
+                }
+                
+                XSD2JavaGenerator codeGen = new XSD2JavaGenerator();
+                try {
+                        codeGen.generateFromXMLSchema( sdoGenCommand );  
+                } catch (IllegalArgumentException e) {
+                            System.out.println("Specified Invalid XSD2Java Arguments.\nFollow the XSD2Java usage, omitting the wsdl/xsd file argument.");
+                            throw new IllegalArgumentException(e);
+                }
+                                    
+                List packages = codeGen.getGeneratedPackageInfo();
+                     
+                for (Iterator iter = packages.iterator(); iter.hasNext();)
+                {
+                    XSD2JavaGenerator.GeneratedPackage packageInfo = (XSD2JavaGenerator.GeneratedPackage)iter.next();
+                    for (Iterator iterClass = packageInfo.getClasses().iterator(); iterClass.hasNext();)
+                    {
+                        XSD2JavaGenerator.GeneratedPackage.PackageClassInfo classInfo = (XSD2JavaGenerator.GeneratedPackage.PackageClassInfo)iterClass.next();
+                        SDODataBindingTypeMappingEntry typeMappingEntry;
+                        if ((genOptions & DYNAMIC_SDO)==0){
+                            
+                            typeMappingEntry = new SDODataBindingTypeMappingEntry(classInfo.getClassName(), classInfo.getAnonymous(), classInfo.getProperties());
+                        } else {
+                            // TO DO implement dynamic sdo case
+                            typeMappingEntry = null;
+                            System.out.println();
+                        }                              
+                        QName qname = new QName(packageInfo.getNamespace(),classInfo.getName());
+                        
+                        //FIXME Workaround for JIRA TUSCANY-1673
+                        // Do not overwrite a typemapping entry describing a element typed by an anonymous
+                        // complex type with a typemapping entry describing a complex type named like the
+                        // element
+                        SDODataBindingTypeMappingEntry existingTypeMapping = typeMapping.get(qname);
+                        if (existingTypeMapping == null || !existingTypeMapping.isAnonymous()) {
+                            typeMapping.put(qname, typeMappingEntry);
+                        }
+                    }          
+                }
+       
+                JavaInterfaceGenerator codeGenerator = new JavaInterfaceGenerator(wsdlFileName,
+                                                                                  ports,
+                                                                                  targetDirectory,
+                                                                                  wsdlJavaPackage,
+                                                                                  typeMapping);
+                codeGenerator.generate();
+        } catch (Exception e) {
+                e.printStackTrace();
+                throw new IllegalArgumentException(e);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public static void generateFromWSDL(String wsdlFileName, String targetDirectory,
+            String wsdlJavaPackage,
+            String xsdJavaPackage, int genOptions){
+        String sdoGenArgsString = null;
+        if (xsdJavaPackage != null){
+            sdoGenArgsString = JAVA_PACKAGE_PARM + " " + xsdJavaPackage;
+        }
+        generateFromWSDL( wsdlFileName, null, targetDirectory, wsdlJavaPackage, genOptions, sdoGenArgsString);
+        
+    }
+    
+    public static void generateFromWSDL(String wsdlFileName, String[] ports,
+                    String targetDirectory, String wsdlJavaPackage,
+                    String xsdJavaPackage, int genOptions) {
+        String sdoGenArgsString = null;
+        if (xsdJavaPackage != null){
+           sdoGenArgsString = JAVA_PACKAGE_PARM + " " + xsdJavaPackage;
+        }
+        generateFromWSDL( wsdlFileName, null, targetDirectory, wsdlJavaPackage, genOptions, sdoGenArgsString);
+    }
+    
+    @SuppressWarnings("unchecked")
+      public static void generateDynamicFromWSDL(String wsdlFileName, String[] ports,
+                 String targetDirectory, String wsdlJavaPackage,
+                 String xsdJavaPackage, int genOptions) 
+     {
+
+        // Initialize the SDO runtime
+        DataObjectUtil.initRuntime();
+        EPackage.Registry packageRegistry = new EPackageRegistryImpl(EPackage.Registry.INSTANCE);
+        ExtendedMetaData extendedMetaData = new BasicExtendedMetaData(packageRegistry);
+        HelperContext context = new HelperContextImpl(extendedMetaData, false);
+        XSDHelper xsdHelper = context.getXSDHelper();
+
+        try {
+            
+            // Load the WSDL file
+            File inputFile = new File(wsdlFileName).getAbsoluteFile();
+            InputStream inputStream = new FileInputStream(inputFile);
+            
+            // Define SDO metadata
+            xsdHelper.define(inputStream, inputFile.toURI().toString());
+
+            if (targetDirectory == null) {
+                targetDirectory = new File(wsdlFileName).getCanonicalFile().getParent();
+            } else {
+                targetDirectory = new File(targetDirectory).getCanonicalPath();
+            }
+
+            // Populate the typeMapping table that will be given to the Axis2 WSDL2Java 
+            Map<QName, SDODataBindingTypeMappingEntry> typeMapping =
+                                    new HashMap<QName, SDODataBindingTypeMappingEntry>();
+            if (!packageRegistry.values().isEmpty()) {
+                ResourceSet resourceSet = DataObjectUtil.createResourceSet();
+
+                // Populate list of GenPackages and a map of GenClasses keyed by EClass 
+                List<GenPackage> genPackages = new ArrayList<GenPackage>();
+                Map<EClass, GenClass> genClasses = new HashMap<EClass, GenClass>();
+                for (Iterator iter = packageRegistry.values().iterator(); iter.hasNext();) {
+                    EPackage currentEPackage = (EPackage)iter.next();
+                    String currentBasePackage = extractBasePackageName(currentEPackage, xsdJavaPackage);
+                    String currentPrefix = CodeGenUtil.capName(currentEPackage.getName());
+
+                    GenPackage currentGenPackage = createGenPackage(currentEPackage, currentBasePackage,
+                                                                    currentPrefix, genOptions, resourceSet);
+                    genPackages.add(currentGenPackage);
+                    for (GenClass genClass : (List<GenClass>)currentGenPackage.getGenClasses()) {
+                        genClasses.put(genClass.getEcoreClass(), genClass);
+                    }
+
+                }
+
+                // Process all the SDO packages
+                // Populate the QName -> interfaceName typeMapping table
+                for (GenPackage currentGenPackage : genPackages) {
+                    EPackage currentEPackage = currentGenPackage.getEcorePackage();
+                    
+                    // Populate the type mappings for all the complex types
+                    for (GenClass genClass : (List<GenClass>)currentGenPackage.getGenClasses()) {
+                        QName qname = new QName(extendedMetaData.getNamespace(currentEPackage),
+                                                extendedMetaData.getName(genClass.getEcoreClass()));
+                        String interfaceName = (DYNAMIC_SDO & genOptions) == DYNAMIC_SDO ? "commonj.sdo.DataObject" : currentGenPackage
+                                .getInterfacePackageName()
+                                + '.' + genClass.getInterfaceName();
+                        SDODataBindingTypeMappingEntry typeMappingEntry =
+                                new SDODataBindingTypeMappingEntry(interfaceName, false, null);
+                        typeMapping.put(qname, typeMappingEntry);
+                    }
+
+                    // Process all the global XSD elements
+                    EClass documentRoot = extendedMetaData.getDocumentRoot(currentEPackage);
+                    if (documentRoot != null) {
+                        for (EStructuralFeature element : (List<EStructuralFeature>)extendedMetaData
+                            .getElements(documentRoot)) {
+                            EClassifier elementType = element.getEType();
+                            
+                            // Handle a complex type
+                            if (elementType instanceof EClass) {
+                                EClass eClass = (EClass)elementType;
+
+                                GenClass genClass = genClasses.get(elementType);
+                                QName qname = new QName(extendedMetaData.getNamespace(currentEPackage),
+                                        extendedMetaData.getName(element));
+                                String interfaceName = (DYNAMIC_SDO & genOptions) == DYNAMIC_SDO ? "commonj.sdo.DataObject" : genClass
+                                        .getGenPackage().getInterfacePackageName()
+                                + '.' + genClass.getInterfaceName();
+                                boolean anonymous = extendedMetaData.isAnonymous(eClass);
+                                
+                                // Build list of property class names
+                                List<String> propertyClassNames=new ArrayList<String>();
+                                for (EStructuralFeature feature : (List<EStructuralFeature>)eClass.getEStructuralFeatures()) {
+                                    EClassifier propertyType = feature.getEType();
+                                    if (propertyType instanceof EClass) {
+                                        GenClass propertyGenClass = genClasses.get(propertyType);
+                                        String propertyClassName = (DYNAMIC_SDO & genOptions) == DYNAMIC_SDO ? "commonj.sdo.DataObject"
+                                                : propertyGenClass.getGenPackage().getInterfacePackageName() + '.'
+                                                               + '.' + propertyGenClass.getInterfaceName();
+                                        propertyClassNames.add(propertyClassName);
+                                    } else if (propertyType instanceof EClassifier) {
+                                        String propertyClassName = propertyType.getInstanceClass().getName();
+                                        propertyClassNames.add(propertyClassName);
+                                    }
+                                }
+
+                                SDODataBindingTypeMappingEntry typeMappingEntry = 
+                                    new SDODataBindingTypeMappingEntry(interfaceName, anonymous, propertyClassNames);
+                                typeMapping.put(qname, typeMappingEntry);
+                                
+                            } else {
+                                
+                                // Handle a simple type
+                                QName qname = new QName(extendedMetaData.getNamespace(currentEPackage),
+                                                        extendedMetaData.getName(element));
+                                String className = elementType.getInstanceClass().getName();
+                                SDODataBindingTypeMappingEntry typeMappingEntry = 
+                                        new SDODataBindingTypeMappingEntry(className, false, null);
+                                typeMapping.put(qname, typeMappingEntry);
+                            }
+                        }
+                    }
+                }
+            }
+
+            try {
+                JavaInterfaceGenerator codeGenerator = new JavaInterfaceGenerator(wsdlFileName,
+                                                                                  ports,
+                                                                                  targetDirectory,
+                                                                                  wsdlJavaPackage,
+                                                                                  typeMapping);
+                codeGenerator.generate();
+            } catch (Exception e) {
+                e.printStackTrace();
+                throw new IllegalArgumentException(e);
+            }
+
+        } catch (IOException e) {
+                e.printStackTrace();
+            throw new IllegalArgumentException(e);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public static GenPackage createGenPackage(EPackage ePackage, String basePackage, String prefix,
+                                              int genOptions, ResourceSet resourceSet) {
+        GenModel genModel = ecore2GenModel(ePackage, basePackage, prefix, genOptions);
+
+        URI ecoreURI = URI.createURI("file:///" + ePackage.getName() + ".ecore");
+        URI genModelURI = ecoreURI.trimFileExtension().appendFileExtension("genmodel");
+
+        Resource ecoreResource = resourceSet.createResource(ecoreURI);
+        ecoreResource.getContents().add(ePackage);
+
+        Resource genModelResource = resourceSet.createResource(genModelURI);
+        genModelResource.getContents().add(genModel);
+
+        return (GenPackage)genModel.getGenPackages().get(0);
+    }
+
+    public static GenModel ecore2GenModel(EPackage ePackage, String basePackage,
+                                          String prefix, int genOptions) {
+        GenModel genModel = GenModelFactory.eINSTANCE.createGenModel();
+        genModel.initialize(Collections.singleton(ePackage));
+
+        genModel.setRootExtendsInterface("");
+        genModel.setRootImplementsInterface("commonj.sdo.DataObject");
+        genModel.setRootExtendsClass("org.apache.tuscany.sdo.impl.DataObjectImpl");
+        genModel.setFeatureMapWrapperInterface("commonj.sdo.Sequence");
+        genModel.setFeatureMapWrapperInternalInterface("org.apache.tuscany.sdo.util.BasicSequence");
+        genModel.setFeatureMapWrapperClass("org.apache.tuscany.sdo.util.BasicSequence");
+        genModel.setSuppressEMFTypes(true);
+        genModel.setSuppressEMFMetaData(true);
+        genModel.setSuppressEMFModelTags(true);
+        genModel.setCanGenerate(true);
+        // FIXME workaround java.lang.NoClassDefFoundError:
+        // org/eclipse/jdt/core/jdom/IDOMNode with 02162006 build
+        genModel.setFacadeHelperClass("Hack");
+        genModel.setForceOverwrite(true);
+
+        GenPackage genPackage = (GenPackage)genModel.getGenPackages().get(0);
+
+        if (basePackage != null) {
+            genPackage.setBasePackage(basePackage);
+        }
+        if (prefix != null) {
+            genPackage.setPrefix(prefix);
+        }
+
+        return genModel;
+    }
+
+    public static String extractBasePackageName(EPackage ePackage, String javaPackage) {
+        String qualifiedName = javaPackage != null ? javaPackage : ePackage.getName();
+        String name = /* CodeGenUtil. */shortName(qualifiedName);
+        String baseName = qualifiedName.substring(0, qualifiedName.length() - name.length());
+        if (javaPackage != null || !name.equals(qualifiedName)) {
+            ePackage.setName(name);
+        }
+        return baseName != null ? /* CodeGenUtil. */safeQualifiedName(baseName) : null;
+    }
+
+    public static String shortName(String qualifiedName) {
+        int index = qualifiedName.lastIndexOf(".");
+        return index != -1 ? qualifiedName.substring(index + 1) : qualifiedName;
+    }
+
+    public static String safeQualifiedName(String qualifiedName) {
+        StringBuffer safeQualifiedName = new StringBuffer();
+        for (StringTokenizer stringTokenizer = new StringTokenizer(qualifiedName, ".");
+            stringTokenizer.hasMoreTokens();) {
+            String name = stringTokenizer.nextToken();
+            safeQualifiedName.append(CodeGenUtil.safeName(name));
+            if (stringTokenizer.hasMoreTokens()) {
+                safeQualifiedName.append('.');
+            }
+        }
+        return safeQualifiedName.toString();
+    }
+    /*
+     * Converts myClassName to MyClassName
+     */
+    public static String normalizeClassName(String className) {
+
+        StringBuffer normalizedClassName = new StringBuffer();
+        
+        String beginPart = className.substring(0,1);
+        String endPart = className.substring(1);
+        
+        normalizedClassName.append(beginPart.toUpperCase());
+        normalizedClassName.append(endPart);
+
+        return normalizedClassName.toString();
+    }
+
+    protected static void printDiagnostic(Diagnostic diagnostic, String indent) {
+        System.out.print(indent);
+        System.out.println(diagnostic.getMessage());
+        for (Iterator i = diagnostic.getChildren().iterator(); i.hasNext();) {
+            printDiagnostic((Diagnostic)i.next(), indent + "  ");
+        }
+    }
+
+    protected static void printUsage() {
+        System.out.println("Usage arguments:");
+        System.out.println("  [ -targetDirectory <target-root-directory> ]");
+        System.out.println("  [ -javaPackage <java-package-name> ]");
+        System.out.println("  [ -dynamicSDO | -generateSDO [ -sdoGenArgs <command-file-name> ]]");
+        System.out.println("  [ -verbose ]");
+        System.out.println("  <wsdl-file>");
+        System.out.println("");
+        System.out.println("Where <command-file-name> is a text file containing valid XSD2Java command\narguments (w/o the wsdl/xsd file name)");
+        System.out.println("For example:");
+        System.out.println("");
+        System.out.println("    WSDL2JavaGenerator -targetDirectory myDir somedir/somefile.wsdl");
+    }
+
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/util/XMLNameUtil.java b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/util/XMLNameUtil.java
new file mode 100644
index 0000000000..d0b325982c
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/java/org/apache/tuscany/tools/wsdl2java/util/XMLNameUtil.java
@@ -0,0 +1,143 @@
+/*
+ * 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.tuscany.tools.wsdl2java.util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class XMLNameUtil {
+
+    /**
+     * Returns a valid Java name from an XML Name.
+     *
+     * @param name
+     * @param isUpperCase
+     * @return a valid Java name from an XML Name
+     */
+    public static String getJavaNameFromXMLName(String name, boolean isUpperCase) {
+        List<String> parsedName = parseName(name, '_');
+        StringBuilder result = new StringBuilder(64 * parsedName.size());
+        for (String nameComponent: parsedName) {
+            if (nameComponent.length() > 0) {
+                if (result.length() > 0 || isUpperCase) {
+                    result.append(Character.toUpperCase(nameComponent.charAt(0)));
+                    result.append(nameComponent.substring(1));
+                } else {
+                    result.append(nameComponent);
+                }
+            }
+        }
+    
+        if (result.length() == 0) {
+            return "_";
+        }
+        if (Character.isJavaIdentifierStart(result.charAt(0))) {
+            return isUpperCase ? result.toString() : decapitalizeName(result.toString());
+        }
+        return "_" + result;
+    }
+
+    /**
+     * Decapitalize a name.
+     * @param name
+     * @return a decapitalized name
+     */
+    public static String decapitalizeName(String name) {
+        if (name.length() == 0) {
+            return name;
+        } else {
+            String lowerName = name.toLowerCase();
+            int i;
+            for (i = 0; i < name.length(); i++) {
+                if (name.charAt(i) == lowerName.charAt(i)) {
+                    break;
+                }
+            }
+            if (i > 1 && i < name.length()) {
+                --i;
+            }
+            return name.substring(0, i).toLowerCase() + name.substring(i);
+        }
+    }
+
+    /**
+     * Parse the given name.
+     *
+     * @param sourceName
+     * @param separator
+     * @return some stuff parsed from the name
+     */
+    private static List<String> parseName(String sourceName, char separator) {
+        List<String> result = new ArrayList<String>();
+        if (sourceName != null) {
+            StringBuilder currentWord = new StringBuilder(64);
+            boolean lastIsLower = false;
+            int index;
+            int length;
+            for (index = 0, length = sourceName.length(); index < length; ++index) {
+                char curChar = sourceName.charAt(index);
+                if (!Character.isJavaIdentifierPart(curChar)) {
+                    curChar = separator;
+                }
+                if (Character.isUpperCase(curChar)
+                    || (!lastIsLower && Character.isDigit(curChar))
+                    || curChar == separator) {
+                    
+                    if (lastIsLower && currentWord.length() > 1 
+                        || curChar == separator && currentWord.length() > 0) {
+                        result.add(currentWord.toString());
+                        currentWord = new StringBuilder(64);
+                    }
+                    lastIsLower = false;
+                } else {
+                    if (!lastIsLower) {
+                        int currentWordLength = currentWord.length();
+                        if (currentWordLength > 1) {
+                            char lastChar = currentWord.charAt(--currentWordLength);
+                            currentWord.setLength(currentWordLength);
+                            result.add(currentWord.toString());
+                            currentWord = new StringBuilder(64);
+                            currentWord.append(lastChar);
+                        }
+                    }
+                    lastIsLower = true;
+                }
+    
+                if (curChar != separator) {
+                    currentWord.append(curChar);
+                }
+            }
+    
+            result.add(currentWord.toString());
+        }
+        return result;
+    }
+    
+    /**
+     * Return an EPackage name for the given namespace.
+     *
+     * @param namespace
+     * @return an EPackage name for the given namespace
+     */
+    public static String getPackageNameFromNamespace(String namespace) {
+       return org.apache.tuscany.sdo.helper.SDOXSDEcoreBuilder.getDefaultPackageName(namespace);
+    }
+
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/resources/META-INF/LICENSE.txt b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/resources/META-INF/LICENSE.txt
new file mode 100644
index 0000000000..0084319535
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/resources/META-INF/LICENSE.txt
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, serviceDefinition marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/resources/RemotableInterfaceTemplate.xsl b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/resources/RemotableInterfaceTemplate.xsl
new file mode 100644
index 0000000000..43005bcdbc
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6/tools/wsdl2java/src/main/resources/RemotableInterfaceTemplate.xsl
@@ -0,0 +1,130 @@
+<!--
+ * 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.    
+-->
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+    <xsl:output method="text"/>
+
+    <!-- import the databinding template-->
+    <xsl:include href="databindsupporter"/>
+    <!-- import the other templates for databinding
+         Note  -  these names would be handled by a special
+         URI resolver during the xslt transformations
+     -->
+    <xsl:include href="externalTemplate"/>
+
+
+    <xsl:template match="/interface">
+
+    <xsl:variable name="isSync"><xsl:value-of select="@isSync"/></xsl:variable>
+    <xsl:variable name="isAsync"><xsl:value-of select="@isAsync"/></xsl:variable>
+    <xsl:variable name="callbackname"><xsl:value-of select="@callbackname"/></xsl:variable>
+    <xsl:variable name="package"><xsl:value-of select="@package"/></xsl:variable>
+
+    /**
+     * <xsl:value-of select="@name"/>.java
+     *
+     * This file was auto-generated from WSDL
+     * by the Apache Axis2 version: #axisVersion# #today#
+     */
+    package <xsl:value-of select="$package"/>;
+
+    import org.osoa.sca.annotations.Remotable;
+    import org.osoa.sca.annotations.Service;
+    
+    /*
+     *  <xsl:value-of select="@name"/> java interface
+     */
+
+    @Remotable
+    @Service
+    public interface <xsl:value-of select="@name"></xsl:value-of> {
+          <xsl:for-each select="method">
+
+            <!-- Code for in-out mep -->
+         <xsl:if test="@mep='12'">
+         <xsl:variable name="outputtype"><xsl:value-of select="output/param/@type"></xsl:value-of></xsl:variable>
+
+        <!-- start of the sync block -->                                          
+         <xsl:if test="$isSync='1'">
+        /**
+         * Auto generated method signatures
+         <xsl:for-each select="input/param[@type!='']">* @param <xsl:value-of select="@name"></xsl:value-of><xsl:text>&#10;         </xsl:text></xsl:for-each>
+         <xsl:for-each select="fault/param[@name!='']">* @throws <xsl:value-of select="@name"></xsl:value-of><xsl:text>&#10;         *</xsl:text></xsl:for-each>
+
+         */
+         public <xsl:choose><xsl:when test="$outputtype=''">void</xsl:when><xsl:otherwise><xsl:value-of select="$outputtype"/></xsl:otherwise></xsl:choose>
+        <xsl:text> </xsl:text><xsl:value-of select="@name"/>(
+         <xsl:for-each select="input/param[@type!='']">
+            <xsl:if test="position()>1">,</xsl:if><xsl:value-of select="@type"/><xsl:text> </xsl:text><xsl:value-of select="@name"/>
+          </xsl:for-each>) throws <xsl:for-each select="fault/param[@name!='']">
+            <xsl:if test="position()>1">,</xsl:if><xsl:text> </xsl:text><xsl:value-of select="@name"/><xsl:if test="position()=last()">,</xsl:if>
+
+          </xsl:for-each> java.rmi.RemoteException;
+        <!-- end of the sync block -->
+        </xsl:if>
+
+       <!-- start of the async block -->
+        <xsl:if test="$isAsync='1'">
+         /**
+          * Auto generated method signature
+         <xsl:for-each select="input/param[@type!='']">* @param <xsl:value-of select="@name"></xsl:value-of><xsl:text>&#10;         </xsl:text></xsl:for-each>
+         <xsl:for-each select="fault/param[@name!='']">* @throws <xsl:value-of select="@name"></xsl:value-of><xsl:text>&#10;         *</xsl:text></xsl:for-each>
+
+          */
+
+        public void start<xsl:value-of select="@name"/>(
+         <xsl:variable name="paramCount"><xsl:value-of select="count(input/param[@type!=''])"></xsl:value-of></xsl:variable>
+               <xsl:for-each select="input/param">
+            <xsl:if test="@type!=''"><xsl:if test="position()>1">,</xsl:if><xsl:value-of select="@type"/><xsl:text> </xsl:text><xsl:value-of select="@name"></xsl:value-of></xsl:if></xsl:for-each>
+           <xsl:if test="$paramCount>0">,</xsl:if>final <xsl:value-of select="$package"/>.<xsl:value-of select="$callbackname"/> callback) throws <xsl:for-each select="fault/param[@name!='']">
+            <xsl:if test="position()>1">,</xsl:if><xsl:text> </xsl:text><xsl:value-of select="@name"/><xsl:if test="position()=last()">,</xsl:if>
+          </xsl:for-each> java.rmi.RemoteException;
+        </xsl:if>
+       <!-- end of async block-->
+
+     </xsl:if>
+        <!-- Code for in-only mep -->
+       <xsl:if test="@mep='10'">
+
+       <!-- For in-only meps there would not be any asynchronous methods since there is no output -->
+         /**
+         * Auto generated method signature
+         <xsl:for-each select="input/param[@type!='']">* @param <xsl:value-of select="@name"></xsl:value-of><xsl:text>&#10;         </xsl:text></xsl:for-each>
+         <xsl:for-each select="fault/param[@name!='']">* @throws <xsl:value-of select="@name"></xsl:value-of><xsl:text>&#10;         *</xsl:text></xsl:for-each>
+         */
+         public  void
+        <xsl:text> </xsl:text><xsl:value-of select="@name"/>(
+         <xsl:for-each select="input/param">
+
+            <xsl:if test="@type!=''"><xsl:if test="position()>1">,</xsl:if><xsl:value-of select="@type"/><xsl:text> </xsl:text><xsl:value-of select="@name"/>
+            </xsl:if>
+         </xsl:for-each>) throws <xsl:for-each select="fault/param[@name!='']">
+            <xsl:if test="position()>1">,</xsl:if><xsl:text> </xsl:text><xsl:value-of select="@name"/><xsl:if test="position()=last()">,</xsl:if>
+          </xsl:for-each> java.rmi.RemoteException;
+
+        </xsl:if>
+
+       </xsl:for-each>
+
+       <!-- Apply other templates --> 
+       //<xsl:apply-templates/>
+       }
+
+
+    </xsl:template>
+   </xsl:stylesheet>
\ No newline at end of file