/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.axis.wsdl.fromJava;
import com.ibm.wsdl.BindingFaultImpl;
import com.ibm.wsdl.extensions.soap.SOAPAddressImpl;
import com.ibm.wsdl.extensions.soap.SOAPBindingImpl;
import com.ibm.wsdl.extensions.soap.SOAPBodyImpl;
import com.ibm.wsdl.extensions.soap.SOAPHeaderImpl;
import com.ibm.wsdl.extensions.soap.SOAPOperationImpl;
import org.apache.axis.AxisFault;
import org.apache.axis.Constants;
import org.apache.axis.InternalException;
import org.apache.axis.Version;
import org.apache.axis.description.FaultDesc;
import org.apache.axis.description.JavaServiceDesc;
import org.apache.axis.description.OperationDesc;
import org.apache.axis.description.ParameterDesc;
import org.apache.axis.description.ServiceDesc;
import org.apache.axis.encoding.DefaultTypeMappingImpl;
import org.apache.axis.encoding.TypeMapping;
import org.apache.axis.enum.Style;
import org.apache.axis.enum.Use;
import org.apache.axis.utils.ClassUtils;
import org.apache.axis.utils.JavaUtils;
import org.apache.axis.utils.Messages;
import org.apache.axis.utils.XMLUtils;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;
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.Output;
import javax.wsdl.Part;
import javax.wsdl.Port;
import javax.wsdl.PortType;
import javax.wsdl.Service;
import javax.wsdl.WSDLException;
import javax.wsdl.extensions.ExtensibilityElement;
import javax.wsdl.extensions.soap.SOAPAddress;
import javax.wsdl.extensions.soap.SOAPBinding;
import javax.wsdl.extensions.soap.SOAPBody;
import javax.wsdl.extensions.soap.SOAPFault;
import javax.wsdl.extensions.soap.SOAPHeader;
import javax.wsdl.extensions.soap.SOAPOperation;
import javax.wsdl.factory.WSDLFactory;
import javax.xml.namespace.QName;
import javax.xml.parsers.ParserConfigurationException;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.Vector;
/**
* This class emits WSDL from Java classes. It is used by the ?WSDL
* Axis browser function and Java2WSDL commandline utility.
* See Java2WSDL and Java2WSDLFactory for more information.
*
* @author Glen Daniels (gdaniels@apache.org)
* @author Rich Scheuerle (scheu@us.ibm.com)
*/
public class Emitter {
// Generated WSDL Modes
/** Field MODE_ALL */
public static final int MODE_ALL = 0;
/** Field MODE_INTERFACE */
public static final int MODE_INTERFACE = 1;
/** Field MODE_IMPLEMENTATION */
public static final int MODE_IMPLEMENTATION = 2;
/** Field cls */
private Class cls;
/** Field extraClasses */
private Class[] extraClasses; // Extra classes to emit WSDL for
/** Field implCls */
private Class implCls; // Optional implementation class
/** Field allowedMethods */
private Vector allowedMethods = null; // Names of methods to consider
/** Field disallowedMethods */
private Vector disallowedMethods = null; // Names of methods to exclude
/** Field stopClasses */
private ArrayList stopClasses =
new ArrayList(); // class names which halt inheritace searches
/** Field useInheritedMethods */
private boolean useInheritedMethods = false;
/** Field intfNS */
private String intfNS;
/** Field implNS */
private String implNS;
/** Field inputSchema */
private String inputSchema;
/** Field inputWSDL */
private String inputWSDL;
/** Field locationUrl */
private String locationUrl;
/** Field importUrl */
private String importUrl;
/** Field servicePortName */
private String servicePortName;
/** Field serviceElementName */
private String serviceElementName;
/** Field targetService */
private String targetService = null;
/** Field description */
private String description;
/** Field style */
private Style style = Style.RPC;
/** Field use */
private Use use = null; // Default depends on style setting
/** Field tm */
private TypeMapping tm = null; // Registered type mapping
/** Field defaultTM */
private TypeMapping defaultTM = null; // Default TM
/** Field namespaces */
private Namespaces namespaces;
/** Field exceptionMsg */
private Map exceptionMsg = null;
/** Field encodingList */
private ArrayList encodingList;
/** Field types */
protected Types types;
/** Field clsName */
private String clsName;
/** Field portTypeName */
private String portTypeName;
/** Field bindingName */
private String bindingName;
/** Field serviceDesc */
private ServiceDesc serviceDesc;
/** Field serviceDesc2 */
private JavaServiceDesc serviceDesc2;
/** Field soapAction */
private String soapAction = "DEFAULT";
// Style Modes
/** DEPRECATED - Indicates style=rpc use=encoded */
public static final int MODE_RPC = 0;
/** DEPRECATED - Indicates style=document use=literal */
public static final int MODE_DOCUMENT = 1;
/** DEPRECATED - Indicates style=wrapped use=literal */
public static final int MODE_DOC_WRAPPED = 2;
/**
* Construct Emitter.
* Set the contextual information using set* methods
* Invoke emit to emit the code
*/
public Emitter() {
createDocumentFragment();
namespaces = new Namespaces();
exceptionMsg = new HashMap();
}
/**
* Generates WSDL documents for a given <code>Class</code>
*
* @param filename1 interface WSDL
* @param filename2 implementation WSDL
* @throws IOException
* @throws WSDLException
* @throws SAXException
* @throws ParserConfigurationException
*/
public void emit(String filename1, String filename2)
throws IOException, WSDLException, SAXException,
ParserConfigurationException {
// Get interface and implementation defs
Definition intf = getIntfWSDL();
Definition impl = getImplWSDL();
// Supply reasonable file names if not supplied
if (filename1 == null) {
filename1 = getServicePortName() + "_interface.wsdl";
}
if (filename2 == null) {
filename2 = getServicePortName() + "_implementation.wsdl";
}
for (int i = 0; (extraClasses != null) && (i < extraClasses.length);
i++) {
types.writeTypeForPart(extraClasses[i], null);
}
// types.updateNamespaces();
// Write out the interface def
Document doc =
WSDLFactory.newInstance().newWSDLWriter().getDocument(intf);
types.insertTypesFragment(doc);
prettyDocumentToFile(doc, filename1);
// Write out the implementation def
doc = WSDLFactory.newInstance().newWSDLWriter().getDocument(impl);
prettyDocumentToFile(doc, filename2);
}
/**
* Generates a complete WSDL document for a given <code>Class</code>
*
* @param filename WSDL
* @throws IOException
* @throws WSDLException
* @throws SAXException
* @throws ParserConfigurationException
*/
public void emit(String filename)
throws IOException, WSDLException, SAXException,
ParserConfigurationException {
emit(filename, MODE_ALL);
}
/**
* Generates a WSDL document for a given <code>Class</code>.
* The WSDL generated is controlled by the mode parameter
* mode 0: All
* mode 1: Interface
* mode 2: Implementation
*
* @param mode generation mode - all, interface, implementation
* @return Document
* @throws IOException
* @throws WSDLException
* @throws SAXException
* @throws ParserConfigurationException
*/
public Document emit(int mode)
throws IOException, WSDLException, SAXException,
ParserConfigurationException {
Document doc = null;
Definition def = null;
switch (mode) {
case MODE_ALL:
def = getWSDL();
for (int i = 0;
(extraClasses != null) && (i < extraClasses.length);
i++) {
types.writeTypeForPart(extraClasses[i], null);
}
// types.updateNamespaces();
doc = WSDLFactory.newInstance().newWSDLWriter().getDocument(
def);
types.insertTypesFragment(doc);
break;
case MODE_INTERFACE:
def = getIntfWSDL();
for (int i = 0;
(extraClasses != null) && (i < extraClasses.length);
i++) {
types.writeTypeForPart(extraClasses[i], null);
}
// types.updateNamespaces();
doc = WSDLFactory.newInstance().newWSDLWriter().getDocument(
def);
types.insertTypesFragment(doc);
break;
case MODE_IMPLEMENTATION:
def = getImplWSDL();
doc = WSDLFactory.newInstance().newWSDLWriter().getDocument(
def);
break;
}
// Add Axis version info as comment to beginnning of generated WSDL
Comment wsdlVersion = doc.createComment(
Messages.getMessage(
"wsdlCreated00",
XMLUtils.xmlEncodeString(Version.getVersion())));
doc.getDocumentElement().insertBefore(
wsdlVersion, doc.getDocumentElement().getFirstChild());
// Return the document
return doc;
}
/**
* Generates a String containing the WSDL for a given <code>Class</code>.
* The WSDL generated is controlled by the mode parameter
* mode 0: All
* mode 1: Interface
* mode 2: Implementation
*
* @param mode generation mode - all, interface, implementation
* @return String
* @throws IOException
* @throws WSDLException
* @throws SAXException
* @throws ParserConfigurationException
*/
public String emitToString(int mode)
throws IOException, WSDLException, SAXException,
ParserConfigurationException {
Document doc = emit(mode);
StringWriter sw = new StringWriter();
XMLUtils.PrettyDocumentToWriter(doc, sw);
return sw.toString();
}
/**
* Generates a WSDL document for a given <code>Class</code>.
* The WSDL generated is controlled by the mode parameter
* mode 0: All
* mode 1: Interface
* mode 2: Implementation
*
* @param filename WSDL
* @param mode generation mode - all, interface, implementation
* @throws IOException
* @throws WSDLException
* @throws SAXException
* @throws ParserConfigurationException
*/
public void emit(String filename, int mode)
throws IOException, WSDLException, SAXException,
ParserConfigurationException {
Document doc = emit(mode);
// Supply a reasonable file name if not supplied
if (filename == null) {
filename = getServicePortName();
switch (mode) {
case MODE_ALL:
filename += ".wsdl";
break;
case MODE_INTERFACE:
filename += "_interface.wsdl";
break;
case MODE_IMPLEMENTATION:
filename += "_implementation.wsdl";
break;
}
}
prettyDocumentToFile(doc, filename);
}
/**
* Get a Full WSDL <code>Definition</code> for the current
* configuration parameters
*
* @return WSDL <code>Definition</code>
* @throws IOException
* @throws WSDLException
* @throws SAXException
* @throws ParserConfigurationException
*/
public Definition getWSDL()
throws IOException, WSDLException, SAXException,
ParserConfigurationException {
// Invoke the init() method to ensure configuration is setup
init(MODE_ALL);
// Create a Definition for the output wsdl
Definition def = createDefinition();
// Write interface header
writeDefinitions(def, intfNS);
// Create Types
types = createTypes(def);
// Write the WSDL constructs and return full Definition
Binding binding = writeBinding(def, true);
writePortType(def, binding);
writeService(def, binding);
return def;
}
/**
* Get a interface WSDL <code>Definition</code> for the
* current configuration parameters
*
* @return WSDL <code>Definition</code>
* @throws IOException
* @throws WSDLException
* @throws SAXException
* @throws ParserConfigurationException
*/
public Definition getIntfWSDL()
throws IOException, WSDLException, SAXException,
ParserConfigurationException {
// Invoke the init() method to ensure configuration is setup
init(MODE_INTERFACE);
// Create a definition for the output wsdl
Definition def = createDefinition();
// Write interface header
writeDefinitions(def, intfNS);
// Create Types
types = createTypes(def);
// Write the interface WSDL constructs and return the Definition
Binding binding = writeBinding(def, true);
writePortType(def, binding);
return def;
}
/**
* Get implementation WSDL <code>Definition</code> for the
* current configuration parameters
*
* @return WSDL <code>Definition</code>
* @throws IOException
* @throws WSDLException
* @throws SAXException
* @throws ParserConfigurationException
*/
public Definition getImplWSDL()
throws IOException, WSDLException, SAXException,
ParserConfigurationException {
// Invoke the init() method to ensure configuration is setup
init(MODE_IMPLEMENTATION);
// Create a Definition for the output wsdl
Definition def = createDefinition();
// Write implementation header and import
writeDefinitions(def, implNS);
writeImport(def, intfNS, importUrl);
// Write the implementation WSDL constructs and return Definition
Binding binding = writeBinding(def, false); // Don't add binding to def
writeService(def, binding);
return def;
}
/**
* Invoked prior to building a definition to ensure parms
* and data are set up.
*
* @param mode
*/
protected void init(int mode) {
// Default use depending on setting of style
if (use == null) {
if (style == Style.RPC) {
use = Use.ENCODED;
} else {
use = Use.LITERAL;
}
}
// Set up a ServiceDesc to use to introspect the Service
if (serviceDesc == null) {
JavaServiceDesc javaServiceDesc = new JavaServiceDesc();
serviceDesc = javaServiceDesc;
javaServiceDesc.setImplClass(cls);
// Set the typeMapping to the one provided.
// If not available use the default TM
if (tm != null) {
serviceDesc.setTypeMapping(tm);
} else {
tm = getDefaultTypeMapping();
serviceDesc.setTypeMapping(tm);
}
javaServiceDesc.setStopClasses(stopClasses);
serviceDesc.setAllowedMethods(allowedMethods);
javaServiceDesc.setDisallowedMethods(disallowedMethods);
serviceDesc.setStyle(style);
// If the class passed in is a portType,
// there may be an implClass that is used to
// obtain the method parameter names. In this case,
// a serviceDesc2 is built to get the method parameter names.
if ((implCls != null) && (implCls != cls)
&& (serviceDesc2 == null)) {
serviceDesc2 = new JavaServiceDesc();
serviceDesc2.setImplClass(implCls);
// Set the typeMapping to the one provided.
// If not available use the default TM
if (tm != null) {
serviceDesc2.setTypeMapping(tm);
} else {
serviceDesc2.setTypeMapping(getDefaultTypeMapping());
}
serviceDesc2.setStopClasses(stopClasses);
serviceDesc2.setAllowedMethods(allowedMethods);
serviceDesc2.setDisallowedMethods(disallowedMethods);
serviceDesc2.setStyle(style);
}
}
if (encodingList == null) {
// if cls contains a Class object with the service implementation use the Name of the
// class else use the service name
if (cls != null) {
clsName = cls.getName();
clsName = clsName.substring(clsName.lastIndexOf('.') + 1);
} else {
clsName = getServiceDesc().getName();
}
// Default the portType name
if (getPortTypeName() == null) {
setPortTypeName(clsName);
}
// Default the serviceElementName
if (getServiceElementName() == null) {
setServiceElementName(getPortTypeName() + "Service");
}
// If service port name is null, construct it from location or className
if (getServicePortName() == null) {
String name = getLocationUrl();
if (name != null) {
if (name.lastIndexOf('/') > 0) {
name = name.substring(name.lastIndexOf('/') + 1);
} else if (name.lastIndexOf('\\') > 0) {
name = name.substring(name.lastIndexOf('\\') + 1);
} else {
name = null;
}
// if we got the name from the location, strip .jws from it
if ((name != null) && name.endsWith(".jws")) {
name = name.substring(0, (name.length()
- ".jws".length()));
}
}
if ((name == null) || name.equals("")) {
name = clsName;
}
setServicePortName(name);
}
// Default the bindingName
if (getBindingName() == null) {
setBindingName(getServicePortName() + "SoapBinding");
}
encodingList = new ArrayList();
encodingList.add(Constants.URI_DEFAULT_SOAP_ENC);
if (intfNS == null) {
Package pkg = cls.getPackage();
intfNS = namespaces.getCreate((pkg == null)
? null
: pkg.getName());
}
// Default the implementation namespace to the interface
// namespace if not split wsdl mode.
if (implNS == null) {
if (mode == MODE_ALL) {
implNS = intfNS;
} else {
implNS = intfNS + "-impl";
}
}
// set the namespaces in the serviceDesc(s)
serviceDesc.setDefaultNamespace(intfNS);
if (serviceDesc2 != null) {
serviceDesc2.setDefaultNamespace(implNS);
}
if (cls != null) {
namespaces.put(cls.getName(), intfNS, "intf");
}
namespaces.putPrefix(implNS, "impl");
}
}
/**
* Build a Definition from the input wsdl file or create
* a new Definition
*
* @return WSDL Definition
* @throws WSDLException
* @throws SAXException
* @throws IOException
* @throws ParserConfigurationException
*/
protected Definition createDefinition()
throws WSDLException, SAXException, IOException,
ParserConfigurationException {
Definition def;
if (inputWSDL == null) {
def = WSDLFactory.newInstance().newDefinition();
} else {
javax.wsdl.xml.WSDLReader reader =
WSDLFactory.newInstance().newWSDLReader();
Document doc = XMLUtils.newDocument(inputWSDL);
def = reader.readWSDL(null, doc);
// The input wsdl types section is deleted. The
// types will be added back in at the end of processing.
def.setTypes(null);
}
return def;
}
/** Field standardTypes */
protected static TypeMapping standardTypes =
(TypeMapping) new org.apache.axis.encoding.TypeMappingRegistryImpl().getTypeMapping(
null);
/**
* Build a Types object and load the input wsdl types
*
* @param def Corresponding wsdl Definition
* @return Types object
* @throws IOException
* @throws WSDLException
* @throws SAXException
* @throws ParserConfigurationException
*/
protected Types createTypes(Definition def)
throws IOException, WSDLException, SAXException,
ParserConfigurationException {
types = new Types(def, tm, getDefaultTypeMapping(), namespaces, intfNS, stopClasses,
serviceDesc);
if (inputWSDL != null) {
types.loadInputTypes(inputWSDL);
}
if (inputSchema != null) {
StringTokenizer tokenizer = new StringTokenizer(inputSchema, ", ");
while (tokenizer.hasMoreTokens()) {
String token = tokenizer.nextToken();
types.loadInputSchema(token);
}
}
return types;
}
/**
* Create the definition header information.
*
* @param def <code>Definition</code>
* @param tns target namespace
*/
protected void writeDefinitions(Definition def, String tns) {
def.setTargetNamespace(tns);
def.addNamespace("intf", intfNS);
def.addNamespace("impl", implNS);
def.addNamespace(Constants.NS_PREFIX_WSDL_SOAP,
Constants.URI_WSDL11_SOAP);
namespaces.putPrefix(Constants.URI_WSDL11_SOAP,
Constants.NS_PREFIX_WSDL_SOAP);
def.addNamespace(Constants.NS_PREFIX_WSDL, Constants.NS_URI_WSDL11);
namespaces.putPrefix(Constants.NS_URI_WSDL11, Constants.NS_PREFIX_WSDL);
if (use == Use.ENCODED) {
def.addNamespace(Constants.NS_PREFIX_SOAP_ENC,
Constants.URI_DEFAULT_SOAP_ENC);
namespaces.putPrefix(Constants.URI_DEFAULT_SOAP_ENC,
Constants.NS_PREFIX_SOAP_ENC);
}
def.addNamespace(Constants.NS_PREFIX_SCHEMA_XSD,
Constants.URI_DEFAULT_SCHEMA_XSD);
namespaces.putPrefix(Constants.URI_DEFAULT_SCHEMA_XSD,
Constants.NS_PREFIX_SCHEMA_XSD);
def.addNamespace(Constants.NS_PREFIX_XMLSOAP, Constants.NS_URI_XMLSOAP);
namespaces.putPrefix(Constants.NS_URI_XMLSOAP,
Constants.NS_PREFIX_XMLSOAP);
}
/**
* Create and add an import
*
* @param def <code>Definition</code>
* @param tns target namespace
* @param loc target location
*/
protected void writeImport(Definition def, String tns, String loc) {
Import imp = def.createImport();
imp.setNamespaceURI(tns);
if ((loc != null) && !loc.equals("")) {
imp.setLocationURI(loc);
}
def.addImport(imp);
}
/**
* Create the binding.
*
* @param def <code>Definition</code>
* @param add true if binding should be added to the def
* @return
*/
protected Binding writeBinding(Definition def, boolean add) {
QName bindingQName = new QName(intfNS, getBindingName());
// If a binding already exists, don't replace it.
Binding binding = def.getBinding(bindingQName);
if (binding != null) {
return binding;
}
// Create a binding
binding = def.createBinding();
binding.setUndefined(false);
binding.setQName(bindingQName);
SOAPBinding soapBinding = new SOAPBindingImpl();
String styleStr = (style == Style.RPC)
? "rpc"
: "document";
soapBinding.setStyle(styleStr);
soapBinding.setTransportURI(Constants.URI_SOAP11_HTTP);
binding.addExtensibilityElement(soapBinding);
if (add) {
def.addBinding(binding);
}
return binding;
}
/** Field docHolder */
Document docHolder;
/**
* Method createDocumentFragment
*/
private void createDocumentFragment() {
try {
this.docHolder = XMLUtils.newDocument();
} catch (ParserConfigurationException e) {
// This should not occur
throw new InternalException(e);
}
}
/**
* Create the service.
*
* @param def
* @param binding
*/
protected void writeService(Definition def, Binding binding) {
QName serviceElementQName = new QName(implNS, getServiceElementName());
// Locate an existing service, or get a new service
Service service = def.getService(serviceElementQName);
if (service == null) {
service = def.createService();
service.setQName(serviceElementQName);
def.addService(service);
}
if (serviceDesc.getDocumentation() != null) {
Element element = docHolder.createElement("documentation");
Text textNode =
docHolder.createTextNode(serviceDesc.getDocumentation());
element.appendChild(textNode);
service.setDocumentationElement(element);
}
// Add the port
Port port = def.createPort();
port.setBinding(binding);
// Probably should use the end of the location Url
port.setName(getServicePortName());
SOAPAddress addr = new SOAPAddressImpl();
addr.setLocationURI(locationUrl);
port.addExtensibilityElement(addr);
service.addPort(port);
}
/**
* Create a PortType
*
* @param def
* @param binding
* @throws WSDLException
* @throws AxisFault
*/
protected void writePortType(Definition def, Binding binding)
throws WSDLException, AxisFault {
QName portTypeQName = new QName(intfNS, getPortTypeName());
// Get or create a portType
PortType portType = def.getPortType(portTypeQName);
boolean newPortType = false;
if (portType == null) {
portType = def.createPortType();
portType.setUndefined(false);
portType.setQName(portTypeQName);
newPortType = true;
} else if (binding.getBindingOperations().size() > 0) {
// If both portType and binding already exist,
// no additional processing is needed.
return;
}
// Add the port and binding operations.
ArrayList operations = serviceDesc.getOperations();
for (Iterator i = operations.iterator(); i.hasNext();) {
OperationDesc thisOper = (OperationDesc) i.next();
BindingOperation bindingOper = writeOperation(def, binding,
thisOper);
Operation oper = bindingOper.getOperation();
OperationDesc messageOper = thisOper;
// add the documentation to oper
if (messageOper.getDocumentation() != null) {
Element element = docHolder.createElement("documentation");
Text textNode =
docHolder.createTextNode(messageOper.getDocumentation());
element.appendChild(textNode);
oper.setDocumentationElement(element);
}
if (serviceDesc2 != null) {
// If a serviceDesc containing an impl class is provided,
// try and locate the corresponding operation
// (same name, same parm types and modes). If a
// corresponding operation is found, it is sent
// to the writeMessages method so that its parameter
// names will be used in the wsdl file.
OperationDesc[] operArray =
serviceDesc2.getOperationsByName(thisOper.getName());
boolean found = false;
if (operArray != null) {
for (int j = 0; (j < operArray.length) && !found; j++) {
OperationDesc tryOper = operArray[j];
if (tryOper.getParameters().size()
== thisOper.getParameters().size()) {
boolean parmsMatch = true;
for (int k =
0; (k < thisOper.getParameters().size())
&& parmsMatch; k++) {
if ((tryOper.getParameter(
k).getMode() != thisOper.getParameter(
k).getMode())
|| (!tryOper.getParameter(
k).getJavaType().equals(
thisOper.getParameter(
k).getJavaType()))) {
parmsMatch = false;
}
}
if (parmsMatch) {
messageOper = tryOper;
found = true;
}
}
}
}
}
writeMessages(def, oper, messageOper, bindingOper);
if (newPortType) {
portType.addOperation(oper);
}
}
if (newPortType) {
def.addPortType(portType);
}
binding.setPortType(portType);
}
/**
* Create a Message
*
* @param def Definition, the WSDL definition
* @param oper Operation, the wsdl operation
* @param desc OperationDesc, the Operation Description
* @param bindingOper BindingOperation, corresponding Binding Operation
* @throws WSDLException
* @throws AxisFault
*/
protected void writeMessages(
Definition def, Operation oper, OperationDesc desc, BindingOperation bindingOper)
throws WSDLException, AxisFault {
Input input = def.createInput();
Message msg = writeRequestMessage(def, desc, bindingOper);
input.setMessage(msg);
// Give the input element a name that matches the
// message. This is necessary for overloading.
// The msg QName is unique.
String name = msg.getQName().getLocalPart();
input.setName(name);
bindingOper.getBindingInput().setName(name);
oper.setInput(input);
def.addMessage(msg);
msg = writeResponseMessage(def, desc, bindingOper);
Output output = def.createOutput();
output.setMessage(msg);
// Give the output element a name that matches the
// message. This is necessary for overloading.
// The message QName is unique.
name = msg.getQName().getLocalPart();
output.setName(name);
bindingOper.getBindingOutput().setName(name);
oper.setOutput(output);
def.addMessage(msg);
ArrayList exceptions = desc.getFaults();
for (int i = 0; (exceptions != null) && (i < exceptions.size()); i++) {
FaultDesc faultDesc = (FaultDesc) exceptions.get(i);
msg = writeFaultMessage(def, faultDesc);
// Add the fault to the portType
Fault fault = def.createFault();
fault.setMessage(msg);
fault.setName(faultDesc.getName());
oper.addFault(fault);
// Add the fault to the binding
BindingFault bFault = def.createBindingFault();
bFault.setName(faultDesc.getName());
SOAPFault soapFault = writeSOAPFault(faultDesc);
bFault.addExtensibilityElement(soapFault);
bindingOper.addBindingFault(bFault);
// Add the fault message
if (def.getMessage(msg.getQName()) == null) {
def.addMessage(msg);
}
}
// Set the parameter ordering using the parameter names
ArrayList parameters = desc.getParameters();
Vector names = new Vector();
for (int i = 0; i < parameters.size(); i++) {
ParameterDesc param = (ParameterDesc) parameters.get(i);
names.add(param.getName());
}
if (names.size() > 0) {
if (style == Style.WRAPPED) {
names.clear();
}
oper.setParameterOrdering(names);
}
}
/**
* Create a Operation
*
* @param def
* @param binding
* @param desc
* @return
*/
protected BindingOperation writeOperation(Definition def, Binding binding,
OperationDesc desc) {
Operation oper = def.createOperation();
oper.setName(desc.getName());
oper.setUndefined(false);
return writeBindingOperation(def, binding, oper, desc);
}
/**
* Create a Binding Operation
*
* @param def
* @param binding
* @param oper
* @param desc
* @return
*/
protected BindingOperation writeBindingOperation(Definition def,
Binding binding, Operation oper, OperationDesc desc) {
BindingOperation bindingOper = def.createBindingOperation();
BindingInput bindingInput = def.createBindingInput();
BindingOutput bindingOutput = def.createBindingOutput();
bindingOper.setName(oper.getName());
bindingOper.setOperation(oper);
SOAPOperation soapOper = new SOAPOperationImpl();
// If the soapAction option is OPERATION, force
// soapAction to the name of the operation. If NONE,
// force soapAction to "".
// Otherwise use the information in the operationDesc.
String soapAction = "";
if (getSoapAction().equals("OPERATION")) {
soapAction = oper.getName();
} else if (getSoapAction().equals("NONE")) {
soapAction = "";
} else {
soapAction = desc.getSoapAction();
if (soapAction == null) {
soapAction = "";
}
}
soapOper.setSoapActionURI(soapAction);
// Until we have per-operation configuration, this will always be
// the same as the binding default.
// soapOper.setStyle("rpc");
bindingOper.addExtensibilityElement(soapOper);
// Add soap:body element to the binding <input> element
ExtensibilityElement inputBody = null;
inputBody = writeSOAPBody(desc.getElementQName());
bindingInput.addExtensibilityElement(inputBody);
// add soap:headers, if any, to binding <input> element
// only when we write the Message and parts.
// Add soap:body element to the binding <output> element
ExtensibilityElement outputBody = null;
outputBody = writeSOAPBody(desc.getReturnQName());
bindingOutput.addExtensibilityElement(outputBody);
// add soap:headers, if any, to binding <output> element
// only when we write the Message and parts.
// Add input and output to operation
bindingOper.setBindingInput(bindingInput);
bindingOper.setBindingOutput(bindingOutput);
// Faults clause
ArrayList faultList = desc.getFaults();
if (faultList != null) {
for (Iterator it = faultList.iterator(); it.hasNext();) {
FaultDesc faultDesc = (FaultDesc) it.next();
// Get a soap:fault
ExtensibilityElement soapFault = writeSOAPFault(faultDesc);
// Get a wsdl:fault to put the soap:fault in
BindingFault bindingFault = new BindingFaultImpl();
bindingFault.setName(faultDesc.getName());
bindingFault.addExtensibilityElement(soapFault);
bindingOper.addBindingFault(bindingFault);
}
}
binding.addBindingOperation(bindingOper);
return bindingOper;
}
/**
* Create a SOAPHeader element
*/
protected SOAPHeader writeSOAPHeader(ParameterDesc p, QName messageQName, String partName)
{
SOAPHeaderImpl soapHeader = new SOAPHeaderImpl();
// for now, if its document, it is literal use.
if (use == Use.ENCODED) {
soapHeader.setUse("encoded");
soapHeader.setEncodingStyles(encodingList);
} else {
soapHeader.setUse("literal");
}
// Set namespace
if (targetService == null) {
soapHeader.setNamespaceURI(intfNS);
} else {
soapHeader.setNamespaceURI(targetService);
}
QName headerQName = p.getQName();
if ((headerQName != null) && !headerQName.getNamespaceURI().equals("")) {
soapHeader.setNamespaceURI(headerQName.getNamespaceURI());
}
// Set the Message and Part information
soapHeader.setMessage(messageQName);
soapHeader.setPart(partName);
return soapHeader;
}
/**
* Method writeSOAPBody
*
* @param operQName
* @return
*/
protected ExtensibilityElement writeSOAPBody(QName operQName) {
SOAPBody soapBody = new SOAPBodyImpl();
// for now, if its document, it is literal use.
if (use == Use.ENCODED) {
soapBody.setUse("encoded");
soapBody.setEncodingStyles(encodingList);
} else {
soapBody.setUse("literal");
}
if (targetService == null) {
soapBody.setNamespaceURI(intfNS);
} else {
soapBody.setNamespaceURI(targetService);
}
if ((operQName != null) && !operQName.getNamespaceURI().equals("")) {
soapBody.setNamespaceURI(operQName.getNamespaceURI());
}
// The parts attribute will get set if we have headers.
// This gets done when the Message & parts are generated
// soapBody.setParts(...);
return soapBody;
} // writeSOAPBody
/**
* Method writeSOAPFault
*
* @param faultDesc
* @return
*/
protected SOAPFault writeSOAPFault(FaultDesc faultDesc) {
SOAPFault soapFault = new com.ibm.wsdl.extensions.soap.SOAPFaultImpl();
soapFault.setName(faultDesc.getName());
if (use != Use.ENCODED) {
soapFault.setUse("literal");
// no namespace for literal, gets it from the element
} else {
soapFault.setUse("encoded");
soapFault.setEncodingStyles(encodingList);
// Set the namespace from the fault QName if it exists
// otherwise use the target (or interface) namespace
QName faultQName = faultDesc.getQName();
if ((faultQName != null)
&& !faultQName.getNamespaceURI().equals("")) {
soapFault.setNamespaceURI(faultQName.getNamespaceURI());
} else {
if (targetService == null) {
soapFault.setNamespaceURI(intfNS);
} else {
soapFault.setNamespaceURI(targetService);
}
}
}
return soapFault;
} // writeSOAPFault
/**
* Create a Request Message
*
* @param def
* @param oper
* @return
* @throws WSDLException
* @throws AxisFault
*/
protected Message writeRequestMessage(Definition def, OperationDesc oper, BindingOperation bindop)
throws WSDLException, AxisFault
{
String partName;
ArrayList bodyParts = new ArrayList();
ArrayList parameters = oper.getAllInParams();
Message msg = def.createMessage();
QName qName = createMessageName(def,
getRequestQName(oper).getLocalPart() + "Request");
msg.setQName(qName);
msg.setUndefined(false);
// output all the parts for headers
boolean headers = writeHeaderParts(def, parameters, bindop, msg, true);
if (oper.getStyle() == Style.MESSAGE) {
// If this is a MESSAGE-style operation, just write out
// <xsd:any> for now.
// TODO: Support custom schema in WSDD for these operations
QName qname = oper.getElementQName();
types.writeElementDecl(qname, Object.class,
Constants.XSD_ANYTYPE, false, false);
Part part = def.createPart();
part.setName("part");
part.setElementName(qname);
msg.addPart(part);
bodyParts.add(part.getName());
} else if (oper.getStyle() == Style.WRAPPED) {
// If we're WRAPPED, write the wrapper element first, and then
// fill in any params. If there aren't any params, we'll see
// an empty <complexType/> for the wrapper element.
partName = writeWrapperPart(def, msg, oper, true);
bodyParts.add(partName);
} else {
// write a part for each non-header parameter
for (int i = 0; i < parameters.size(); i++) {
ParameterDesc parameter = (ParameterDesc) parameters.get(i);
if (!parameter.isInHeader() && !parameter.isOutHeader()) {
partName = writePartToMessage(def, msg, true, parameter);
bodyParts.add(partName);
}
}
}
// If we have headers, we must fill in the parts attribute of soap:body
// if not, we just leave it out (which means all parts)
if (headers) {
// Find soap:body in binding
List extensibilityElements = bindop.getBindingInput().getExtensibilityElements();
for (int i = 0; i < extensibilityElements.size(); i++)
{
Object ele = extensibilityElements.get(i);
if (ele instanceof SOAPBodyImpl)
{
SOAPBodyImpl soapBody = (SOAPBodyImpl) ele;
soapBody.setParts(bodyParts);
}
}
}
return msg;
}
/**
* Create parts of a Message for header parameters and write then in
* to the provided Message element. Also create a soap:header element
* in the binding
*
* @param parameters the list of parameters for the current operation
* @param bindop the current bindingOperation
* @param msg the message to add the parts to
* @param request true if we are do an input message, false if it is output
* @return true if we wrote any header parts
*/
private boolean writeHeaderParts(Definition def,
ArrayList parameters,
BindingOperation bindop,
Message msg,
boolean request) throws WSDLException, AxisFault
{
boolean wroteHeaderParts = false;
String partName;
// Loop over all the parameters for this operation
for (int i = 0; i < parameters.size(); i++) {
ParameterDesc parameter = (ParameterDesc) parameters.get(i);
// write the input or output header parts in to the Message
if (request && parameter.isInHeader()) {
// put part in message
partName = writePartToMessage(def, msg, request, parameter);
// Create a soap:header element
SOAPHeader hdr = writeSOAPHeader(parameter, msg.getQName(), partName);
// put it in the binding <input> element
bindop.getBindingInput().addExtensibilityElement(hdr);
wroteHeaderParts = true;
}
else if (!request && parameter.isOutHeader()) {
// put part in message
partName = writePartToMessage(def, msg, request, parameter);
// Create a soap:header element
SOAPHeader hdr = writeSOAPHeader(parameter, msg.getQName(), partName);
// put it in the binding <output> element
bindop.getBindingOutput().addExtensibilityElement(hdr);
wroteHeaderParts = true;
}
else {
continue; // body part
}
}
return wroteHeaderParts;
}
/**
* Method getRequestQName
*
* @param oper
* @return
*/
protected QName getRequestQName(OperationDesc oper) {
qualifyOperation(oper);
QName qname = oper.getElementQName();
if (qname == null) {
qname = new QName(oper.getName());
}
return qname;
}
/**
* Method qualifyOperation
*
* @param oper
*/
private void qualifyOperation(OperationDesc oper) {
if ((style == Style.WRAPPED) && (use == Use.LITERAL)) {
QName qname = oper.getElementQName();
if (qname == null) {
qname = new QName(intfNS, oper.getName());
} else if (qname.getNamespaceURI().equals("")) {
qname = new QName(intfNS, qname.getLocalPart());
}
oper.setElementQName(qname);
}
}
/**
* Method getResponseQName
*
* @param oper
* @return
*/
protected QName getResponseQName(OperationDesc oper) {
qualifyOperation(oper);
QName qname = oper.getElementQName();
if (qname == null) {
return new QName(oper.getName() + "Response");
}
return new QName(qname.getNamespaceURI(),
qname.getLocalPart() + "Response");
}
/**
* Write out the schema definition for a WRAPPED operation request or
* response.
*
* @param def
* @param msg
* @param oper
* @param request
* @return the name of the part the was written
* @throws AxisFault
*/
public String writeWrapperPart(
Definition def, Message msg, OperationDesc oper, boolean request)
throws AxisFault {
QName qname = request
? getRequestQName(oper)
: getResponseQName(oper);
boolean hasParams = false;
if (request) {
hasParams = (oper.getNumInParams() > 0);
} else {
if (oper.getReturnClass() != void.class) {
hasParams = true;
} else {
hasParams = (oper.getNumOutParams() > 0);
}
}
// First write the wrapper element itself.
Element sequence = types.writeWrapperElement(qname, request, hasParams);
// If we got anything back above, there must be parameters in the
// operation, and it's a <sequence> node in which to write them...
if (sequence != null) {
ArrayList parameters = request
? oper.getAllInParams()
: oper.getAllOutParams();
if (!request) {
String retName;
if (oper.getReturnQName() == null) {
retName = oper.getName() + "Return";
} else {
retName = oper.getReturnQName().getLocalPart();
}
types.writeWrappedParameter(sequence, retName,
oper.getReturnType(),
oper.getReturnClass());
}
for (int i = 0; i < parameters.size(); i++) {
ParameterDesc parameter = (ParameterDesc) parameters.get(i);
// avoid headers
if (!parameter.isInHeader() && !parameter.isOutHeader())
{
types.writeWrappedParameter(sequence,
parameter.getName(), // QName??
parameter.getTypeQName(),
parameter.getJavaType());
}
}
}
// Finally write the part itself
Part part = def.createPart();
part.setName("parameters"); // We always use "parameters"
part.setElementName(qname);
msg.addPart(part);
return part.getName();
}
/**
* Create a Response Message
*
* @param def
* @param desc
* @return
* @throws WSDLException
* @throws AxisFault
*/
protected Message writeResponseMessage(Definition def, OperationDesc desc, BindingOperation bindop)
throws WSDLException, AxisFault
{
String partName;
ArrayList bodyParts = new ArrayList();
ArrayList parameters = desc.getAllOutParams();
Message msg = def.createMessage();
QName qName =
createMessageName(def, getResponseQName(desc).getLocalPart());
msg.setQName(qName);
msg.setUndefined(false);
// output all the parts for headers
boolean headers = writeHeaderParts(def, parameters, bindop, msg, false);
if (desc.getStyle() == Style.WRAPPED) {
partName = writeWrapperPart(def, msg, desc, false);
bodyParts.add(partName);
} else {
// Write the return value part
ParameterDesc retParam = new ParameterDesc();
if (desc.getReturnQName() == null) {
String ns = "";
if (desc.getStyle() != Style.RPC) {
ns = getServiceDesc().getDefaultNamespace();
if ((ns == null) || "".equals(ns)) {
ns = "http://ws.apache.org/axis/defaultNS";
}
}
retParam.setQName(new QName(ns, desc.getName() + "Return"));
} else {
retParam.setQName(desc.getReturnQName());
}
retParam.setTypeQName(desc.getReturnType());
retParam.setMode(ParameterDesc.OUT);
retParam.setIsReturn(true);
retParam.setJavaType(desc.getReturnClass());
String returnPartName = writePartToMessage(def, msg, false, retParam);
bodyParts.add(returnPartName);
// write a part for each non-header parameter
for (int i = 0; i < parameters.size(); i++) {
ParameterDesc parameter = (ParameterDesc) parameters.get(i);
if (!parameter.isInHeader() && !parameter.isOutHeader()) {
partName = writePartToMessage(def, msg, false, parameter);
bodyParts.add(partName);
}
}
}
// If we have headers, we must fill in the parts attribute of soap:body
// if not, we just leave it out (which means all parts)
if (headers) {
// Find soap:body in binding
List extensibilityElements = bindop.getBindingOutput().getExtensibilityElements();
for (int i = 0; i < extensibilityElements.size(); i++)
{
Object ele = extensibilityElements.get(i);
if (ele instanceof SOAPBodyImpl)
{
SOAPBodyImpl soapBody = (SOAPBodyImpl) ele;
soapBody.setParts(bodyParts);
}
}
}
return msg;
}
/**
* Create a Fault Message
*
* @param def
* @param exception (an ExceptionRep object)
* @return
* @throws WSDLException
* @throws AxisFault
*/
protected Message writeFaultMessage(Definition def, FaultDesc exception)
throws WSDLException, AxisFault {
String pkgAndClsName = exception.getClassName();
String clsName =
pkgAndClsName.substring(pkgAndClsName.lastIndexOf('.') + 1,
pkgAndClsName.length());
// Do this to cover the complex type case with no meta data
exception.setName(clsName);
// The following code uses the class name for both the name= attribute
// and the message= attribute.
Message msg = (Message) exceptionMsg.get(pkgAndClsName);
if (msg == null) {
msg = def.createMessage();
QName qName = createMessageName(def, clsName);
msg.setQName(qName);
msg.setUndefined(false);
ArrayList parameters = exception.getParameters();
if (parameters != null) {
for (int i = 0; i < parameters.size(); i++) {
ParameterDesc parameter = (ParameterDesc) parameters.get(i);
writePartToMessage(def, msg, true, parameter);
}
}
exceptionMsg.put(pkgAndClsName, msg);
}
return msg;
}
/**
* Create a Part
*
* @param def
* @param msg
* @param request message is for a request
* @param param ParamRep object
* @return The parameter name added or null
* @throws WSDLException
* @throws AxisFault
*/
public String writePartToMessage(
Definition def, Message msg, boolean request, ParameterDesc param)
throws WSDLException, AxisFault {
// Return if this is a void type
if ((param == null) || (param.getJavaType() == java.lang.Void.TYPE)) {
return null;
}
// If Request message, only continue if IN or INOUT
// If Response message, only continue if OUT or INOUT
if (request && (param.getMode() == ParameterDesc.OUT)) {
return null;
}
if (!request && (param.getMode() == ParameterDesc.IN)) {
return null;
}
// Create the Part
Part part = def.createPart();
if (param.getDocumentation() != null) {
Element element = docHolder.createElement("documentation");
Text textNode =
docHolder.createTextNode(param.getDocumentation());
element.appendChild(textNode);
part.setDocumentationElement(element);
}
// Get the java type to represent in the wsdl
// (if the mode is OUT or INOUT and this
// parameter does not represent the return type,
// the type held in the Holder is the one that should
// be written.)
Class javaType = param.getJavaType();
if ((param.getMode() != ParameterDesc.IN)
&& (param.getIsReturn() == false)) {
javaType = JavaUtils.getHolderValueType(javaType);
}
if ((use == Use.ENCODED) || (style == Style.RPC)) {
// Add the type representing the param
// Write <part name=param_name type=param_type>
QName typeQName = param.getTypeQName();
if (javaType != null) {
typeQName = types.writeTypeAndSubTypeForPart(javaType, typeQName);
}
// types.writeElementForPart(javaType, param.getTypeQName());
if (typeQName != null) {
part.setName(param.getName());
part.setTypeName(typeQName);
msg.addPart(part);
}
} else if (use == Use.LITERAL) {
// This is doc/lit. So we should write out an element
// declaration whose name and type may be found in the
// ParameterDesc.
QName qname = param.getQName();
if (param.getTypeQName() == null) {
throw new AxisFault(
Messages.getMessage(
"registerTypeMappingFor01",
param.getJavaType().getName()));
}
if (param.getTypeQName().getNamespaceURI().equals("")) {
param.setTypeQName(
new QName(intfNS, param.getTypeQName().getLocalPart()));
}
if (param.getQName().getNamespaceURI().equals("")) {
qname = new QName(intfNS, param.getQName().getLocalPart());
param.setQName(qname);
}
types.writeElementDecl(qname, param.getJavaType(),
param.getTypeQName(), false, false);
part.setName(param.getName());
part.setElementName(qname);
msg.addPart(part);
}
// return the name of the parameter added
return param.getName();
}
/*
* Return a message QName which has not already been defined in the WSDL
*/
/**
* Method createMessageName
*
* @param def
* @param methodName
* @return
*/
protected QName createMessageName(Definition def, String methodName) {
QName qName = new QName(intfNS, methodName);
// Check the make sure there isn't a message with this name already
int messageNumber = 1;
while (def.getMessage(qName) != null) {
StringBuffer namebuf = new StringBuffer(methodName);
namebuf.append(messageNumber);
qName = new QName(intfNS, namebuf.toString());
messageNumber++;
}
return qName;
}
/**
* Write a prettified document to a file.
*
* @param doc the Document to write
* @param filename the name of the file to be written
* @throws IOException various file i/o exceptions
*/
protected void prettyDocumentToFile(Document doc, String filename)
throws IOException {
FileOutputStream fos = new FileOutputStream(new File(filename));
XMLUtils.PrettyDocumentToStream(doc, fos);
fos.close();
}
// -------------------- Parameter Query Methods ----------------------------//
/**
* Returns the <code>Class</code> to export
*
* @return the <code>Class</code> to export
*/
public Class getCls() {
return cls;
}
/**
* Sets the <code>Class</code> to export
*
* @param cls the <code>Class</code> to export
*/
public void setCls(Class cls) {
this.cls = cls;
}
/**
* Sets the <code>Class</code> to export.
*
* @param cls the <code>Class</code> to export
* @param location
*/
public void setClsSmart(Class cls, String location) {
if ((cls == null) || (location == null)) {
return;
}
// Strip off \ and / from location
if (location.lastIndexOf('/') > 0) {
location = location.substring(location.lastIndexOf('/') + 1);
} else if (location.lastIndexOf('\\') > 0) {
location = location.substring(location.lastIndexOf('\\') + 1);
}
// Get the constructors of the class
java.lang.reflect.Constructor[] constructors =
cls.getDeclaredConstructors();
Class intf = null;
for (int i = 0; (i < constructors.length) && (intf == null); i++) {
Class[] parms = constructors[i].getParameterTypes();
// If the constructor has a single parameter
// that is an interface which
// matches the location, then use this as the interface class.
if ((parms.length == 1) && parms[0].isInterface()
&& (parms[0].getName() != null)
&& Types.getLocalNameFromFullName(
parms[0].getName()).equals(location)) {
intf = parms[0];
}
}
if (intf != null) {
setCls(intf);
if (implCls == null) {
setImplCls(cls);
}
} else {
setCls(cls);
}
}
/**
* Sets the <code>Class</code> to export
*
* @param className the name of the <code>Class</code> to export
* @throws ClassNotFoundException
*/
public void setCls(String className) throws ClassNotFoundException {
cls = ClassUtils.forName(className);
}
/**
* Returns the implementation <code>Class</code> if set
*
* @return the implementation Class or null
*/
public Class getImplCls() {
return implCls;
}
/**
* Sets the implementation <code>Class</code>
*
* @param implCls the <code>Class</code> to export
*/
public void setImplCls(Class implCls) {
this.implCls = implCls;
}
/**
* Sets the implementation <code>Class</code>
*
* @param className the name of the implementation <code>Class</code>
*/
public void setImplCls(String className) {
try {
implCls = ClassUtils.forName(className);
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* Returns the interface namespace
*
* @return interface target namespace
*/
public String getIntfNamespace() {
return intfNS;
}
/**
* Set the interface namespace
*
* @param ns interface target namespace
*/
public void setIntfNamespace(String ns) {
this.intfNS = ns;
}
/**
* Returns the implementation namespace
*
* @return implementation target namespace
*/
public String getImplNamespace() {
return implNS;
}
/**
* Set the implementation namespace
*
* @param ns implementation target namespace
*/
public void setImplNamespace(String ns) {
this.implNS = ns;
}
/**
* Returns a vector of methods to export
*
* @return a space separated list of methods to export
*/
public Vector getAllowedMethods() {
return allowedMethods;
}
/**
* Add a list of methods to export
*
* @param text
*/
public void setAllowedMethods(String text) {
if (text != null) {
StringTokenizer tokenizer = new StringTokenizer(text, " ,+");
if (allowedMethods == null) {
allowedMethods = new Vector();
}
while (tokenizer.hasMoreTokens()) {
allowedMethods.add(tokenizer.nextToken());
}
}
}
/**
* Add a Vector of methods to export
*
* @param allowedMethods a vector of methods to export
*/
public void setAllowedMethods(Vector allowedMethods) {
if (this.allowedMethods == null) {
this.allowedMethods = new Vector();
}
this.allowedMethods.addAll(allowedMethods);
}
/**
* Indicates if the emitter will search classes for inherited methods
*
* @return
*/
public boolean getUseInheritedMethods() {
return useInheritedMethods;
}
/**
* Turn on or off inherited method WSDL generation.
*
* @param useInheritedMethods
*/
public void setUseInheritedMethods(boolean useInheritedMethods) {
this.useInheritedMethods = useInheritedMethods;
}
/**
* Add a list of methods NOT to export
*
* @param disallowedMethods vector of method name strings
*/
public void setDisallowedMethods(Vector disallowedMethods) {
if (this.disallowedMethods == null) {
this.disallowedMethods = new Vector();
}
this.disallowedMethods.addAll(disallowedMethods);
}
/**
* Add a list of methods NOT to export
*
* @param text space separated list of method names
*/
public void setDisallowedMethods(String text) {
if (text != null) {
StringTokenizer tokenizer = new StringTokenizer(text, " ,+");
if (disallowedMethods == null) {
disallowedMethods = new Vector();
}
disallowedMethods = new Vector();
while (tokenizer.hasMoreTokens()) {
disallowedMethods.add(tokenizer.nextToken());
}
}
}
/**
* Return list of methods that should not be exported
*
* @return
*/
public Vector getDisallowedMethods() {
return disallowedMethods;
}
/**
* Adds a list of classes (fully qualified) that will stop the traversal
* of the inheritance tree if encounter in method or complex type generation
*
* @param stopClasses vector of class name strings
*/
public void setStopClasses(ArrayList stopClasses) {
if (this.stopClasses == null) {
this.stopClasses = new ArrayList();
}
this.stopClasses.addAll(stopClasses);
}
/**
* Add a list of classes (fully qualified) that will stop the traversal
* of the inheritance tree if encounter in method or complex type generation
*
* @param text space separated list of class names
*/
public void setStopClasses(String text) {
if (text != null) {
StringTokenizer tokenizer = new StringTokenizer(text, " ,+");
if (stopClasses == null) {
stopClasses = new ArrayList();
}
while (tokenizer.hasMoreTokens()) {
stopClasses.add(tokenizer.nextToken());
}
}
}
/**
* Return the list of classes which stop inhertance searches
*
* @return
*/
public ArrayList getStopClasses() {
return stopClasses;
}
/**
* get the packagename to namespace map
*
* @return <code>Map</code>
*/
public Map getNamespaceMap() {
return namespaces;
}
/**
* Set the packagename to namespace map with the given map
*
* @param map packagename/namespace <code>Map</code>
*/
public void setNamespaceMap(Map map) {
if (map != null) {
namespaces.putAll(map);
}
}
/**
* Get the name of the input WSDL
*
* @return name of the input wsdl or null
*/
public String getInputWSDL() {
return inputWSDL;
}
/**
* Set the name of the input WSDL
*
* @param inputWSDL the name of the input WSDL
*/
public void setInputWSDL(String inputWSDL) {
this.inputWSDL = inputWSDL;
}
/**
* @return the name of the input schema, or null
*/
public String getInputSchema() {
return inputSchema;
}
/**
* Set the name of the input schema
*
* @param inputSchema the name of the input schema
*/
public void setInputSchema(String inputSchema) {
this.inputSchema = inputSchema;
}
/**
* Returns the String representation of the service endpoint URL
*
* @return String representation of the service endpoint URL
*/
public String getLocationUrl() {
return locationUrl;
}
/**
* Set the String representation of the service endpoint URL
*
* @param locationUrl the String representation of the service endpoint URL
*/
public void setLocationUrl(String locationUrl) {
this.locationUrl = locationUrl;
}
/**
* Returns the String representation of the interface import location URL
*
* @return String representation of the interface import location URL
*/
public String getImportUrl() {
return importUrl;
}
/**
* Set the String representation of the interface location URL
* for importing
*
* @param importUrl the String representation of the interface
* location URL for importing
*/
public void setImportUrl(String importUrl) {
this.importUrl = importUrl;
}
/**
* Returns the String representation of the service port name
*
* @return String representation of the service port name
*/
public String getServicePortName() {
return servicePortName;
}
/**
* Set the String representation of the service port name
*
* @param servicePortName the String representation of the service port name
*/
public void setServicePortName(String servicePortName) {
this.servicePortName = servicePortName;
}
/**
* Returns the String representation of the service element name
*
* @return String representation of the service element name
*/
public String getServiceElementName() {
return serviceElementName;
}
/**
* Set the String representation of the service element name
*
* @param serviceElementName the String representation of the service element name
*/
public void setServiceElementName(String serviceElementName) {
this.serviceElementName = serviceElementName;
}
/**
* Returns the String representation of the portType name
*
* @return String representation of the portType name
*/
public String getPortTypeName() {
return portTypeName;
}
/**
* Set the String representation of the portType name
*
* @param portTypeName the String representation of the portType name
*/
public void setPortTypeName(String portTypeName) {
this.portTypeName = portTypeName;
}
/**
* Returns the String representation of the binding name
*
* @return String representation of the binding name
*/
public String getBindingName() {
return bindingName;
}
/**
* Set the String representation of the binding name
*
* @param bindingName the String representation of the binding name
*/
public void setBindingName(String bindingName) {
this.bindingName = bindingName;
}
/**
* Returns the target service name
*
* @return the target service name
*/
public String getTargetService() {
return targetService;
}
/**
* Set the target service name
*
* @param targetService the target service name
*/
public void setTargetService(String targetService) {
this.targetService = targetService;
}
/**
* Returns the service description
*
* @return service description String
*/
public String getDescription() {
return description;
}
/**
* Set the service description
*
* @param description service description String
*/
public void setDescription(String description) {
this.description = description;
}
/**
* Returns the soapAction option value
*
* @return the String DEFAULT, NONE or OPERATION
*/
public String getSoapAction() {
return soapAction;
}
/**
* Sets the soapAction option value
*
* @param value must be DEFAULT, NONE, or OPERATION
*/
public void setSoapAction(String value) {
soapAction = value;
}
/**
* Returns the <code>TypeMapping</code> used by the service
*
* @return the <code>TypeMapping</code> used by the service
*/
public TypeMapping getTypeMapping() {
return tm;
}
/**
* Sets the <code>TypeMapping</code> used by the service
*
* @param tm the <code>TypeMapping</code> used by the service
*/
public void setTypeMapping(TypeMapping tm) {
this.tm = tm;
}
/**
* Returns the default <code>TypeMapping</code> used by the service
*
* @return the default <code>TypeMapping</code> used by the service
*/
public TypeMapping getDefaultTypeMapping() {
if (defaultTM == null) {
defaultTM = DefaultTypeMappingImpl.getSingleton();
}
return defaultTM;
}
/**
* Sets the default <code>TypeMapping</code> used by the service
*
* @param defaultTM the default <code>TypeMapping</code> used by the service
*/
public void setDefaultTypeMapping(TypeMapping defaultTM) {
this.defaultTM = defaultTM;
}
/**
* getStyle
*
* @return Style setting (Style.RPC, Style.DOCUMENT, Style.WRAPPED, etc.)
*/
public Style getStyle() {
return style;
}
/**
* setStyle
*
* @param value String representing a style ("document", "rpc", "wrapped")
* Note that the case of the string is not important. "document" and "DOCUMENT"
* are both treated as document style.
* If the value is not a know style, the default setting is used.
* See org.apache.axis.enum.Style for a description of the interaction between
* Style/Use
* <br>NOTE: If style is specified as "wrapped", use is set to literal.
*/
public void setStyle(String value) {
setStyle(Style.getStyle(value));
}
/**
* setStyle
*
* @param value Style setting
*/
public void setStyle(Style value) {
style = value;
if (style.equals(Style.WRAPPED)) {
setUse(Use.LITERAL);
}
}
/**
* getUse
*
* @return Use setting (Use.ENCODED, Use.LITERAL)
*/
public Use getUse() {
return use;
}
/**
* setUse
*
* @param value String representing a use ("literal", "encoded")
* Note that the case of the string is not important. "literal" and "LITERAL"
* are both treated as literal use.
* If the value is not a know use, the default setting is used.
* See org.apache.axis.enum.Style for a description of the interaction between
* Style/Use
*/
public void setUse(String value) {
use = Use.getUse(value);
}
/**
* setUse
*
* @param value Use setting
*/
public void setUse(Use value) {
use = value;
}
/**
* setMode (sets style and use)
*
* @param mode
* @deprecated (use setStyle and setUse)
*/
public void setMode(int mode) {
if (mode == MODE_RPC) {
setStyle(Style.RPC);
setUse(Use.ENCODED);
} else if (mode == MODE_DOCUMENT) {
setStyle(Style.DOCUMENT);
setUse(Use.LITERAL);
} else if (mode == MODE_DOC_WRAPPED) {
setStyle(Style.WRAPPED);
setUse(Use.LITERAL);
}
}
/**
* getMode (gets the mode based on the style setting)
*
* @return returns the mode (-1 if invalid)
* @deprecated (use getStyle and getUse)
*/
public int getMode() {
if (style == Style.RPC) {
return MODE_RPC;
} else if (style == Style.DOCUMENT) {
return MODE_DOCUMENT;
} else if (style == Style.WRAPPED) {
return MODE_DOC_WRAPPED;
}
return -1;
}
/**
* Method getServiceDesc
*
* @return
*/
public ServiceDesc getServiceDesc() {
return serviceDesc;
}
/**
* Method setServiceDesc
*
* @param serviceDesc
*/
public void setServiceDesc(ServiceDesc serviceDesc) {
this.serviceDesc = serviceDesc;
}
/**
* Return the list of extra classes that the emitter will produce WSDL for.
*
* @return
*/
public Class[] getExtraClasses() {
return extraClasses;
}
/**
* Provide a list of classes which the emitter will produce WSDL
* type definitions for.
*
* @param extraClasses
*/
public void setExtraClasses(Class[] extraClasses) {
this.extraClasses = extraClasses;
}
/**
* Provide a comma or space seperated list of classes which
* the emitter will produce WSDL type definitions for.
* The classes will be added to the current list.
*
* @param text
* @throws ClassNotFoundException
*/
public void setExtraClasses(String text) throws ClassNotFoundException {
ArrayList clsList = new ArrayList();
if (text != null) {
StringTokenizer tokenizer = new StringTokenizer(text, " ,");
while (tokenizer.hasMoreTokens()) {
String clsName = tokenizer.nextToken();
// Let the caller handler ClassNotFoundException
Class cls = ClassUtils.forName(clsName);
clsList.add(cls);
}
}
// Allocate the new array
Class[] ec;
if (extraClasses != null) {
ec = new Class[clsList.size() + extraClasses.length];
// copy existing elements
for (int i = 0; i < extraClasses.length; i++) {
Class c = extraClasses[i];
ec[i] = c;
}
} else {
ec = new Class[clsList.size()];
}
// copy the new classes
for (int i = 0; i < clsList.size(); i++) {
Class c = (Class) clsList.get(i);
ec[i] = c;
}
// set the member variable
this.extraClasses = ec;
}
}