| /* | |
| * Copyright 2003-2004 The Apache Software Foundation. | |
| // (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved | |
| * | |
| * 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.wsdl2ws.info; | |
| import java.io.IOException; | |
| import java.util.ArrayList; | |
| import java.util.Iterator; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.Vector; | |
| import javax.wsdl.Binding; | |
| import javax.wsdl.BindingInput; | |
| import javax.wsdl.BindingOperation; | |
| import javax.wsdl.Fault; | |
| import javax.wsdl.Operation; | |
| import javax.wsdl.Part; | |
| import javax.wsdl.Port; | |
| import javax.wsdl.PortType; | |
| import javax.wsdl.Service; | |
| import javax.wsdl.WSDLElement; | |
| import javax.wsdl.extensions.soap.SOAPBinding; | |
| import javax.wsdl.extensions.soap.SOAPBody; | |
| import javax.wsdl.extensions.soap.SOAPOperation; | |
| import javax.wsdl.extensions.soap.SOAPAddress; | |
| import javax.xml.namespace.QName; | |
| import javax.xml.rpc.holders.BooleanHolder; | |
| import javax.xml.rpc.holders.IntHolder; | |
| import org.apache.axis.Constants; | |
| import org.apache.axis.wsdl.gen.Parser; | |
| import org.apache.axis.wsdl.symbolTable.BindingEntry; | |
| import org.apache.axis.wsdl.symbolTable.CContainedAttribute; | |
| import org.apache.axis.wsdl.symbolTable.CElementDecl; | |
| import org.apache.axis.wsdl.symbolTable.CSchemaUtils; | |
| import org.apache.axis.wsdl.symbolTable.CollectionElement; | |
| import org.apache.axis.wsdl.symbolTable.CollectionType; | |
| import org.apache.axis.wsdl.symbolTable.DefinedElement; | |
| import org.apache.axis.wsdl.symbolTable.Element; | |
| import org.apache.axis.wsdl.symbolTable.Parameters; | |
| import org.apache.axis.wsdl.symbolTable.SchemaUtils; | |
| import org.apache.axis.wsdl.symbolTable.ServiceEntry; | |
| import org.apache.axis.wsdl.symbolTable.SymTabEntry; | |
| import org.apache.axis.wsdl.symbolTable.SymbolTable; | |
| import org.apache.axis.wsdl.symbolTable.TypeEntry; | |
| import org.apache.axis.wsdl.toJava.Utils; | |
| import org.apache.axis.wsdl.wsdl2ws.CUtils; | |
| import org.apache.axis.wsdl.wsdl2ws.WrapperFault; | |
| import org.w3c.dom.Node; | |
| import org.w3c.dom.NodeList; | |
| /** | |
| * This class initiates the collection of various bits of information needed by the | |
| * wsdl2ws tool by parsing the WSDL file. | |
| * | |
| * @author nadir amra | |
| * | |
| */ | |
| public class WSDLInfo | |
| { | |
| // Private constants for retrieving extensibility elements. | |
| private static final int INSTANCEOF_SOAPBINDING = 1; | |
| private static final int INSTANCEOF_SOAPADDRESS = 2; | |
| private static final int INSTANCEOF_SOAPBODY = 3; | |
| private static final int INSTANCEOF_SOAPOPERATION = 4; | |
| // verbose flag | |
| private boolean c_verbose = false; | |
| // parser timeout value, in seconds. 0=no timeout. | |
| private long c_timeout = 0; | |
| // URI to WSDL document. | |
| private String c_URIToWSDLDocument = null; | |
| // Whether wrapper-style is not requested. | |
| private boolean c_noWrapperStyle = false; | |
| // WSDL parser from the last time parse() was invoked. | |
| private Parser c_wsdlParser = null; | |
| // Symbol table associated with the parser. | |
| private SymbolTable c_symbolTable = null; | |
| // Types generated as result of symbolTable | |
| private TypeMap c_typeMap = null; | |
| // Target name space of WSDL | |
| private String c_targetNameSpaceOfWSDL = null; | |
| // Service definitions in WSDL | |
| ArrayList c_services = new ArrayList(); | |
| // Maps service definition to set of ports that use RPC binding style | |
| ArrayList c_bindings = new ArrayList(); | |
| private static boolean useCounter = false; | |
| private static int typeCounter = 1; | |
| /** | |
| * Constructor. | |
| */ | |
| public WSDLInfo(String uri) | |
| { | |
| c_URIToWSDLDocument = uri; | |
| } | |
| /** | |
| * Initiates the parsing of the WSDL document. Returns the symbol table that is generated | |
| * by the parser. After parsing the WSDL document, various artifacts that the wsdl2ws tool needs | |
| * is collected for easy access. | |
| * | |
| * @throws Exception | |
| */ | |
| public SymbolTable parse() throws Exception | |
| { | |
| // ================================================== | |
| // Parse WSDL document | |
| // ================================================== | |
| c_wsdlParser = new Parser(); | |
| // Set verbose in WSDL parser | |
| c_wsdlParser.setVerbose(c_verbose); | |
| // Set timeout for parser, setTimeout method expects the time in milliseconds. | |
| c_wsdlParser.setTimeout(c_timeout*1000); | |
| // Set unwrapped if requested | |
| c_wsdlParser.setNowrap(c_noWrapperStyle); | |
| // Parse the WSDL document. | |
| c_wsdlParser.run(c_URIToWSDLDocument); | |
| c_symbolTable = c_wsdlParser.getSymbolTable(); | |
| // Dump symbol table if in verbose mode. | |
| if (c_verbose) | |
| c_symbolTable.dump(System.out); | |
| // ================================================== | |
| // Collect various bits of information from the document. | |
| // ================================================== | |
| // Get target name space of WSDL | |
| c_targetNameSpaceOfWSDL = c_symbolTable.getDefinition().getTargetNamespace(); | |
| // Collect services and bindings. | |
| Iterator it = c_symbolTable.getHashMap().values().iterator(); | |
| while (it.hasNext()) | |
| { | |
| Vector v = (Vector) it.next(); | |
| for (int i = 0; i < v.size(); ++i) | |
| { | |
| SymTabEntry entry = (SymTabEntry) v.elementAt(i); | |
| if (entry instanceof org.apache.axis.wsdl.symbolTable.ServiceEntry) | |
| c_services.add(((ServiceEntry) entry).getService()); | |
| else if (entry instanceof org.apache.axis.wsdl.symbolTable.BindingEntry) | |
| c_bindings.add(entry); | |
| } | |
| } | |
| // Iterate through the symbol table, generating user-defined types and | |
| // storing the types in a hash table. We need to do this twice. We need | |
| // to first go through the types and ensure there is no type with a suffix of | |
| // _Array, which is used by this code to generate arrays. If there is, we need to | |
| // generate array types with a modified suffix, such as _Array + number. | |
| c_typeMap = new TypeMap(); | |
| if (c_symbolTable != null) | |
| { | |
| it = c_symbolTable.getTypeIndex().values().iterator(); | |
| while (it.hasNext()) | |
| { | |
| TypeEntry type = (TypeEntry) it.next(); | |
| Node node = type.getNode(); | |
| if (node != null) | |
| { | |
| if (type.getQName().getLocalPart().endsWith("_Array")) | |
| useCounter = true; | |
| } | |
| } | |
| it = c_symbolTable.getTypeIndex().values().iterator(); | |
| while (it.hasNext()) | |
| { | |
| TypeEntry type = (TypeEntry) it.next(); | |
| Node node = type.getNode(); | |
| if (node != null) | |
| { | |
| if (c_verbose) | |
| { | |
| System.out.println( "==>getTypeInfo: Processing type...." + type.getQName()); | |
| } | |
| createTypeInfo(type); | |
| } | |
| } | |
| } | |
| // ================================================== | |
| // Return the symbol table | |
| // ================================================== | |
| return c_symbolTable; | |
| } | |
| /** | |
| * Sets the WSDL parser timeout value. | |
| * | |
| * @param t timeout value in seconds. Null implies 0 timeout (no timeout). | |
| */ | |
| public void setTimeout(long t) | |
| { | |
| c_timeout = t; | |
| } | |
| /** | |
| * Sets the WSDL parser verbose mode. | |
| * | |
| * @param b true=verbose; false=no verbose. | |
| */ | |
| public void setVerbose(boolean b) | |
| { | |
| c_verbose = b; | |
| } | |
| /** | |
| * Indicates whether wrapper-style interfaces is allowed. | |
| * | |
| * @param b true=no wrapper style; false=allow wrapper style. | |
| */ | |
| public void setNoWrapperStyle(boolean b) | |
| { | |
| c_noWrapperStyle = b; | |
| } | |
| /** | |
| * Returns target name space of WSDL. | |
| * | |
| * @return String representing the target name space of WSDL. | |
| */ | |
| public String getTargetNameSpaceOfWSDL() | |
| { | |
| return c_targetNameSpaceOfWSDL; | |
| } | |
| /** | |
| * Returns array of services defined in WSDL. The array | |
| * may be empty if service was not defined in WSDL. | |
| * | |
| * @return array of java.wsdl.Service objects. | |
| */ | |
| public ArrayList getServices() | |
| { | |
| return c_services; | |
| } | |
| /** | |
| * Returns end point URI for a Port by looking for the soap:address extensibility element. | |
| * | |
| * @param port | |
| * @return | |
| */ | |
| public static String getTargetEndPointURI(Port port) | |
| { | |
| SOAPAddress e = (SOAPAddress)getExtensibilityElement(port, INSTANCEOF_SOAPADDRESS); | |
| if (e != null) | |
| return e.getLocationURI(); | |
| return null; | |
| } | |
| /** | |
| * Returns the transport URI in a soap:binding element. | |
| * | |
| * @param binding | |
| * @return | |
| */ | |
| public static String getTransportType(Binding binding) | |
| { | |
| SOAPBinding e = (SOAPBinding)getExtensibilityElement(binding, INSTANCEOF_SOAPBINDING); | |
| if (e != null) | |
| return e.getTransportURI(); | |
| return null; | |
| } | |
| /** | |
| * @return the c_typeMap | |
| */ | |
| public TypeMap getTypeMap() | |
| { | |
| return c_typeMap; | |
| } | |
| /** | |
| * Return the binding entry matching the local name. | |
| * | |
| * @param name | |
| * @return | |
| */ | |
| public BindingEntry getBindEntry(String name) | |
| { | |
| Iterator it = c_bindings.iterator(); | |
| while (it.hasNext()) | |
| { | |
| BindingEntry be = (BindingEntry)it.next(); | |
| if (be.getBinding().getQName().getLocalPart().equals(name)) | |
| return be; | |
| } | |
| return null; | |
| } | |
| /** | |
| * Returns the Port that references the specified binding entry from a service definition. | |
| * | |
| * @param s | |
| * @param be | |
| * @return | |
| */ | |
| public static Port getPort(Service s, BindingEntry be) | |
| { | |
| Iterator ports = s.getPorts().values().iterator(); | |
| while (ports.hasNext()) | |
| { | |
| Port p = (Port) ports.next(); | |
| Binding b = p.getBinding(); | |
| if (be.getBinding().getQName().equals(b.getQName())) | |
| return p; | |
| } | |
| return null; | |
| } | |
| /** | |
| * Checks if binding entry is SOAP 1.1 binding. | |
| * @param be | |
| * @return | |
| */ | |
| public static boolean isSOAP11Binding(BindingEntry be) | |
| { | |
| return isSOAPBinding(be, Constants.URI_WSDL11_SOAP); | |
| } | |
| /** | |
| * Checks if SOAP 1.2 binding. | |
| * @param be | |
| * @return | |
| */ | |
| public static boolean isSOAP12Binding(BindingEntry be) | |
| { | |
| return isSOAPBinding(be, Constants.URI_WSDL12_SOAP); | |
| } | |
| /** | |
| * Updates MethodInfo with information from the binding operation element. | |
| * | |
| * @param bindingOp | |
| * @param method | |
| */ | |
| public static void updateMethodInfoFromBinding(BindingOperation bindingOp, MethodInfo method) | |
| { | |
| // Get SOAPAction | |
| SOAPOperation e = (SOAPOperation)getExtensibilityElement(bindingOp, INSTANCEOF_SOAPOPERATION); | |
| if (e != null) | |
| method.setSoapAction(e.getSoapActionURI()); | |
| // Get information about input operation | |
| BindingInput bi = bindingOp.getBindingInput(); | |
| SOAPBody body = (SOAPBody)getExtensibilityElement(bi, INSTANCEOF_SOAPBODY); | |
| if (body != null) | |
| { | |
| method.setInputNamespaceURI(body.getNamespaceURI()); | |
| } | |
| } | |
| /** | |
| * Generate service name given a binding. | |
| * | |
| * @param bindingEntry | |
| * @return | |
| * @throws WrapperFault | |
| */ | |
| public static String getServiceName(BindingEntry bindingEntry) throws WrapperFault | |
| { | |
| PortType portType = bindingEntry.getBinding().getPortType(); | |
| if (portType == null) | |
| throw new WrapperFault("Port type specified in binding '" + bindingEntry.getBinding().getQName().getLocalPart() + "' not found"); | |
| return CUtils.getNameFromFullyQualifiedName(portType.getQName().getLocalPart()); | |
| } | |
| /** | |
| * Returns list of Port objects in the specified service. All ports in the list | |
| * will have a binding style of document and uses the SOAP 1.1 binding. | |
| * | |
| * @param s service definition | |
| * @return list of ports that match the criteria described above. | |
| * @throws Exception | |
| */ | |
| public ArrayList getPortsSOAP11Document(Service s) throws Exception | |
| { | |
| return getServicePorts(s, true, true, false, false); | |
| } | |
| /** | |
| * Returns list of Port objects in the specified service. All ports in the list | |
| * will have a binding style of rpc and uses the SOAP 1.1 binding. | |
| * | |
| * @param s service definition | |
| * @return list of ports that match the criteria described above. | |
| * @throws Exception | |
| */ | |
| public ArrayList getPortsSOAP11RPC(Service s) throws Exception | |
| { | |
| return getServicePorts(s, false, true, false, false); | |
| } | |
| /** | |
| * Returns list of Port objects in the specified service. All ports in the list | |
| * will have a binding style of document and uses the SOAP 1.2 binding. | |
| * | |
| * @param s service definition | |
| * @return list of ports that match the criteria described above. | |
| * @throws Exception | |
| */ | |
| public ArrayList getPortsSOAP12Document(Service s) throws Exception | |
| { | |
| return getServicePorts(s, true, false, true, false); | |
| } | |
| /** | |
| * Returns list of Port objects in the specified service. All ports in the list | |
| * will have a binding style of rpc and uses the SOAP 1.2 binding. | |
| * | |
| * @param s service definition | |
| * @return list of ports that match the criteria described above. | |
| * @throws Exception | |
| */ | |
| public ArrayList getPortsSOAP12RPC(Service s) throws Exception | |
| { | |
| return getServicePorts(s, false, false, true, false); | |
| } | |
| /** | |
| * Returns list of Port objects in the specified service. All ports in the list | |
| * uses the HTTP binding. | |
| * | |
| * @param s | |
| * @param styleDocument | |
| * @return | |
| * @throws Exception | |
| */ | |
| public ArrayList getPortsREST(Service s) throws Exception | |
| { | |
| return getServicePorts(s, true, false, false, true); | |
| } | |
| /** | |
| * Returns list of Port objects in a service definition based on selection criteria. | |
| * | |
| * @param s service definition. | |
| * @param styleDocument true=return document style; false=return "rpc" style. | |
| * This parameter is ignored for REST (HTTP) bindings. | |
| * @param soap11 true=return SOAP 1.1 bindings; false=SOAP 1.1 bindings are ignored. | |
| * @param soap12 true=return SOAP 1.2 bindings; false=SOAP 1.2 bindings are ignored. | |
| * @param rest true=return HTTP bindings; false=ignore HTTP bindings. | |
| * @return List of ports that match selection criteria. | |
| * @throws Exception | |
| */ | |
| private ArrayList getServicePorts(Service s, | |
| boolean styleDocument, | |
| boolean soap11, | |
| boolean soap12, | |
| boolean rest) throws Exception | |
| { | |
| ArrayList a = new ArrayList(); | |
| if (s == null) | |
| return a; | |
| Iterator ports = s.getPorts().values().iterator(); | |
| while (ports.hasNext()) | |
| { | |
| Port p = (Port) ports.next(); | |
| Binding b = p.getBinding(); | |
| BindingEntry be = c_symbolTable.getBindingEntry(b.getQName()); | |
| if (b == null || be == null) | |
| throw new WrapperFault("No binding exists for port '" + p.getName() + "'."); | |
| if ((be.getBindingType() == BindingEntry.TYPE_SOAP) && (soap11 || soap12)) | |
| { | |
| String style = be.getBindingStyle().getName(); | |
| if (style == null) | |
| style = "document"; | |
| if ((styleDocument && style.equalsIgnoreCase("document")) | |
| || (!styleDocument && style.equalsIgnoreCase("rpc"))) | |
| { | |
| String ns = Constants.URI_WSDL11_SOAP; | |
| SOAPBinding soapbinding = (SOAPBinding)getExtensibilityElement(b, INSTANCEOF_SOAPBINDING); | |
| if (soapbinding != null && null != soapbinding.getElementType().getNamespaceURI()) | |
| ns = soapbinding.getElementType().getNamespaceURI(); | |
| if ((soap11 && ns.equals(Constants.URI_WSDL11_SOAP)) | |
| || (soap12 && ns.equals(Constants.URI_WSDL12_SOAP))) | |
| a.add(p); | |
| } | |
| } | |
| else if (rest && (be.getBindingType() == BindingEntry.TYPE_HTTP_GET | |
| || be.getBindingType() == BindingEntry.TYPE_HTTP_POST)) | |
| { | |
| a.add(p); | |
| } | |
| } | |
| return a; | |
| } | |
| /** | |
| * Helper function that returns requested extensibility element. | |
| * | |
| * @param e element to retrieve extensibility elements from. | |
| * @param clazz instance of class | |
| * @return extensibility element. | |
| */ | |
| private static Object getExtensibilityElement(WSDLElement e, int clazz) | |
| { | |
| if (e != null) | |
| { | |
| List extElems = e.getExtensibilityElements(); | |
| if (extElems != null) | |
| { | |
| Iterator it = extElems.iterator(); | |
| while (it.hasNext()) | |
| { | |
| Object o = it.next(); | |
| if ((clazz == INSTANCEOF_SOAPBINDING && (o instanceof javax.wsdl.extensions.soap.SOAPBinding)) | |
| || (clazz == INSTANCEOF_SOAPADDRESS && (o instanceof javax.wsdl.extensions.soap.SOAPAddress)) | |
| || (clazz == INSTANCEOF_SOAPOPERATION && (o instanceof javax.wsdl.extensions.soap.SOAPOperation)) | |
| || (clazz == INSTANCEOF_SOAPBODY && (o instanceof javax.wsdl.extensions.soap.SOAPBody))) | |
| return o; | |
| } | |
| } | |
| } | |
| return null; | |
| } | |
| /** | |
| * Generate a type for the specified QName. | |
| * | |
| * @param typename | |
| * @return | |
| * @throws WrapperFault | |
| */ | |
| private Type createTypeInfo(QName typename) throws WrapperFault | |
| { | |
| TypeEntry type = c_symbolTable.getType(typename); | |
| if (type == null) | |
| { | |
| type = c_symbolTable.getElement(typename); | |
| if (type == null) | |
| throw new WrapperFault("[" + typename + "]unexpected condition occurred. "); | |
| } | |
| return createTypeInfo(type); | |
| } | |
| /** | |
| * Creates a type map entry from a symbol table typeentry. | |
| * | |
| * @param type | |
| * @return | |
| * @throws WrapperFault | |
| */ | |
| private Type createTypeInfo(TypeEntry type) throws WrapperFault | |
| { | |
| Type typedata = null; | |
| Type newSecondaryType = null; | |
| // Do not add types which are not used in the WSDL | |
| if (!type.isReferenced()) | |
| return null; | |
| if (c_verbose && !CUtils.isPrimitiveType(type.getQName())) | |
| System.out.println("Attempting to create type: " + type.getQName()); | |
| if (type instanceof CollectionElement) | |
| { //an array | |
| } | |
| else if (type instanceof DefinedElement) | |
| { | |
| // if element references another type, process the referenced type | |
| if (type.getRefType() != null) | |
| { | |
| if (c_verbose) | |
| System.out.println("Attempting to create new type from element-ref: " + type.getRefType().getQName()); | |
| return createTypeInfo(type.getRefType()); | |
| } | |
| return null; | |
| } | |
| if (-1 != type.getQName().getLocalPart().indexOf('[')) | |
| { | |
| // An array... | |
| // Get referenced type | |
| if (null == type.getRefType() || null == type.getRefType().getQName()) | |
| throw new WrapperFault("Array type found without a Ref type: " + type.getQName()); | |
| // TODO not sure what we should do if array references an element following commented code is not correct | |
| // if (type.getRefType().getRefType() != null) | |
| // qn = type.getRefType().getRefType().getQName(); | |
| QName qn = type.getRefType().getQName(); | |
| // If referenced type is primitive, we are done... | |
| if (CUtils.isPrimitiveType(qn)) | |
| return null; | |
| // Create array | |
| QName newqn; | |
| if (useCounter) | |
| { | |
| newqn = CUtils.getArrayQNameForType(qn); | |
| if (newqn == null) | |
| newqn = new QName(type.getQName().getNamespaceURI(), CUtils.sanitizeString(qn.getLocalPart()) + "_Array" + typeCounter++); | |
| } | |
| else | |
| newqn = new QName(type.getQName().getNamespaceURI(), CUtils.sanitizeString(qn.getLocalPart()) + "_Array"); | |
| // type is a inbuilt type or an already created type? | |
| typedata = c_typeMap.getType(newqn); | |
| if (typedata != null) | |
| { | |
| if (typedata.isArray()) | |
| { | |
| if (c_verbose && !CUtils.isPrimitiveType(type.getQName())) | |
| System.out.println("Type not created, already exists: " + type.getQName()); | |
| return typedata; | |
| } | |
| else | |
| { | |
| // There is a type with the _Array suffix in WSDL that was already processed. | |
| // If an array type was not already created, create one with different name. | |
| QName arrayQName = CUtils.getArrayQNameForType(qn); | |
| if (arrayQName == null) | |
| { | |
| do | |
| { | |
| newqn = new QName(type.getQName().getNamespaceURI(), CUtils.sanitizeString(qn.getLocalPart()) + "_Array" + typeCounter++); | |
| typedata = c_typeMap.getType(newqn); | |
| } | |
| while (typedata != null && !typedata.isArray()); | |
| if (typedata == null) | |
| { | |
| if (c_verbose) | |
| System.out.println("Type clash, change type name to : " + newqn); | |
| } | |
| else | |
| { | |
| if (c_verbose && !CUtils.isPrimitiveType(type.getQName())) | |
| System.out.println("Type not created, already exists: " + type.getQName()); | |
| return typedata; | |
| } | |
| } | |
| else | |
| { | |
| if (c_verbose) | |
| System.out.println("Type not created, already exists: " + type.getQName()); | |
| return c_typeMap.getType(arrayQName); | |
| } | |
| } | |
| } | |
| typedata = new Type(newqn, newqn.getLocalPart()); | |
| CUtils.addArrayType(qn, newqn); | |
| if (type.getRefType().getRefType() != null) | |
| typedata.setElementType(type.getRefType().getRefType().getQName().getLocalPart()); | |
| else | |
| typedata.setElementType(type.getRefType().getQName().getLocalPart()); | |
| } | |
| else | |
| { | |
| // type is a inbuilt type or a already created type? | |
| typedata = c_typeMap.getType(type.getQName()); | |
| if (typedata != null) | |
| { | |
| if (!typedata.isArray()) | |
| { | |
| if (c_verbose && !CUtils.isPrimitiveType(type.getQName())) | |
| System.out.println("Type not created, already exists: " + type.getQName()); | |
| } | |
| return typedata; | |
| } | |
| typedata = new Type(type.getQName(), type.getQName().getLocalPart()); | |
| } | |
| // Add type to type map | |
| if (c_verbose) | |
| System.out.println("Created new type: " + typedata.getName()); | |
| c_typeMap.addType(typedata.getName(), typedata); | |
| // TODO revisit...work out whether this type will be generated or not | |
| typedata.externalize(isTypeGenerated(type, typedata)); | |
| Node node = type.getNode(); | |
| if (type.isSimpleType()) | |
| { | |
| //check for extended types | |
| TypeEntry base = CSchemaUtils.getComplexElementExtensionBase(type.getNode(), c_symbolTable); | |
| if (base != null) | |
| { | |
| String localpart = type.getQName().getLocalPart() + "_value"; | |
| QName typeName = new QName(type.getQName().getNamespaceURI(), localpart); | |
| newSecondaryType = createTypeInfo(base.getQName()); | |
| typedata.addRelatedType(newSecondaryType); | |
| typedata.setExtensionBaseType(new CElementDecl(newSecondaryType, typeName)); | |
| if (c_verbose) | |
| System.out.print( | |
| "=====complexType with simpleContent is found : " | |
| + type.getQName().getLocalPart() + "=====\n"); | |
| } | |
| else | |
| setRestrictionBaseAndValues(typedata, node); | |
| // There can be attributes in this extended basic type | |
| Vector attributes = CSchemaUtils.getContainedAttributeTypes(type.getNode(), c_symbolTable); | |
| if (attributes != null) | |
| { | |
| for (int j = 0; j < attributes.size(); j++) | |
| { | |
| CContainedAttribute attr = (CContainedAttribute)attributes.get(j); | |
| newSecondaryType = createTypeInfo(attr.getTypeEntry().getQName()); | |
| attr.setType(newSecondaryType); | |
| typedata.addRelatedType(newSecondaryType); | |
| } | |
| typedata.addAttributes(attributes); | |
| } | |
| } | |
| else if (type instanceof CollectionType) | |
| { | |
| typedata.setArray(true); | |
| newSecondaryType = createTypeInfo(type.getRefType().getQName()); | |
| typedata.addRelatedType(newSecondaryType); | |
| typedata.setTypeNameForElementName(new CElementDecl(newSecondaryType, type.getQName())); | |
| } | |
| else | |
| { | |
| //is this a SOAPEnc array type | |
| QName arrayType = CSchemaUtils.getArrayComponentQName(node,new IntHolder(0),c_symbolTable); | |
| if (arrayType != null) | |
| { | |
| typedata.setArray(true); | |
| newSecondaryType = createTypeInfo(arrayType); | |
| typedata.addRelatedType(newSecondaryType); | |
| typedata.setTypeNameForElementName(new CElementDecl(newSecondaryType, new QName("item"))); | |
| } | |
| else if ((arrayType = CSchemaUtils.getCollectionComponentQName(node)) != null) | |
| { | |
| typedata.setArray(true); | |
| newSecondaryType = createTypeInfo(arrayType); | |
| typedata.addRelatedType(newSecondaryType); | |
| typedata.setTypeNameForElementName(new CElementDecl(newSecondaryType, new QName("item"))); | |
| } | |
| //Note in a array the parameter type is stored as under the name item all the time | |
| else | |
| { | |
| // get all extended types | |
| Vector extendList = new Vector(); | |
| extendList.add(type); | |
| TypeEntry parent = CSchemaUtils.getComplexElementExtensionBase(type.getNode(), c_symbolTable); | |
| while (parent != null) | |
| { | |
| extendList.add(parent); | |
| parent = CSchemaUtils.getComplexElementExtensionBase(parent.getNode(), c_symbolTable); | |
| } | |
| // Now generate a list of names and types starting with | |
| // the oldest parent. (Attrs are considered before elements). | |
| for (int i = extendList.size() - 1; i >= 0; i--) | |
| { | |
| TypeEntry te = (TypeEntry) extendList.elementAt(i); | |
| //TODO the code require the attributes name at extension base types | |
| //different, the WSDL2Ws do not support it having same name at up and below. | |
| // Process the attributes | |
| if (c_verbose) | |
| System.out.println("Processing attributes for type: " + type.getQName()); | |
| // TODO Need to handle whether attributes are qualified? | |
| Vector attributes = CSchemaUtils.getContainedAttributeTypes(te.getNode(), c_symbolTable); | |
| if (attributes != null) | |
| { | |
| for (int j = 0; j < attributes.size(); j++) | |
| { | |
| CContainedAttribute attr = (CContainedAttribute)attributes.get(j); | |
| newSecondaryType = createTypeInfo(attr.getTypeEntry().getQName()); | |
| attr.setType(newSecondaryType); | |
| typedata.addRelatedType(newSecondaryType); | |
| } | |
| typedata.addAttributes(attributes); | |
| } | |
| // Process the elements | |
| if (c_verbose) | |
| System.out.println("Processing elements for type: " + type.getQName()); | |
| Vector elements = CSchemaUtils.getContainedElementDeclarations(te.getNode(), c_symbolTable); | |
| if (elements != null) | |
| { | |
| // The following will get elementFormDefault for the schema the element is in. | |
| boolean nsQualifyElementDefault = CSchemaUtils.isElementFormDefaultQualified(te.getNode()); | |
| // Now process the elements. | |
| for (int j = 0; j < elements.size(); j++) | |
| { | |
| CElementDecl elem = (CElementDecl) elements.get(j); | |
| // Set whether to namespace qualify or not. We only process if not set. | |
| if (!elem.getNsQualified()) | |
| { | |
| boolean nsQualifyElement = | |
| CSchemaUtils.shouldWeNamespaceQualifyNode(elem.getTypeEntry().getNode(), | |
| nsQualifyElementDefault); | |
| elem.setNsQualified(nsQualifyElement); | |
| } | |
| if (elem.getAnyElement()) | |
| { | |
| newSecondaryType = new Type(); | |
| } | |
| else | |
| { | |
| QName typeName = elem.getTypeEntry().getQName(); | |
| if (typeName.getLocalPart().indexOf('[') > 0) | |
| { | |
| String localpart = | |
| typeName.getLocalPart().substring(0, typeName.getLocalPart().indexOf('[')); | |
| typeName = new QName(typeName.getNamespaceURI(), localpart); | |
| if (CUtils.isPrimitiveType(typeName)) | |
| newSecondaryType = createTypeInfo(typeName); | |
| else | |
| newSecondaryType = createTypeInfo(elem.getTypeEntry()); | |
| } | |
| else | |
| newSecondaryType = createTypeInfo(typeName); | |
| } | |
| typedata.addRelatedType(newSecondaryType); | |
| elem.setType(newSecondaryType); | |
| typedata.setTypeNameForElementName(elem); | |
| } | |
| } | |
| } // for-loop | |
| } | |
| } | |
| return typedata; | |
| } | |
| /** | |
| * Returns the actual referenced type (i.e. a defined type or base type) | |
| * | |
| * @param type | |
| * @return | |
| */ | |
| private TypeEntry getActualRefType(TypeEntry type) | |
| { | |
| if (type == null) | |
| return null; | |
| TypeEntry rt = type.getRefType(); | |
| if (rt != null) | |
| { | |
| if (rt instanceof org.apache.axis.wsdl.symbolTable.DefinedType | |
| || rt instanceof org.apache.axis.wsdl.symbolTable.BaseType) | |
| return rt; | |
| } | |
| return getActualRefType(rt); | |
| } | |
| /** | |
| * If the specified node represents a supported JAX-RPC restriction, | |
| * a Vector is returned which contains the base type and the values (enumerations etc). | |
| * The first element in the vector is the base type (an TypeEntry). | |
| * Subsequent elements are QNames. | |
| * NEEDS WORK - CURRENTLY THE ONLY THING WE DO IS GENERATE ENUMERATOR CONSTANTS AND CREATE | |
| * AN EMPTY RESTRICTOR FUNCTION WHEN DOING CODE GENERATION STEP. | |
| */ | |
| private void setRestrictionBaseAndValues(Type typedata, Node node) | |
| { | |
| if (node == null) | |
| return; | |
| // If the node kind is an element, dive into it. | |
| QName nodeKind = Utils.getNodeQName(node); | |
| if (nodeKind != null && | |
| nodeKind.getLocalPart().equals("element") && | |
| Constants.isSchemaXSD(nodeKind.getNamespaceURI())) | |
| { | |
| NodeList children = node.getChildNodes(); | |
| Node simpleNode = null; | |
| for (int j = 0; j < children.getLength() && simpleNode == null; j++) | |
| { | |
| QName simpleKind = Utils.getNodeQName(children.item(j)); | |
| if (simpleKind != null && | |
| simpleKind.getLocalPart().equals("simpleType") && | |
| Constants.isSchemaXSD(simpleKind.getNamespaceURI())) | |
| { | |
| simpleNode = children.item(j); | |
| node = simpleNode; | |
| } | |
| } | |
| } | |
| // Get the node kind, expecting a schema simpleType | |
| nodeKind = Utils.getNodeQName(node); | |
| if (nodeKind != null && | |
| nodeKind.getLocalPart().equals("simpleType") && | |
| Constants.isSchemaXSD(nodeKind.getNamespaceURI())) | |
| { | |
| // Under the simpleType there may be a restriction, list, or union. | |
| // (There may be other #text nodes, which we will ignore). | |
| // We do something special for unions and lists. We treat them | |
| // as strings and ignore the processing of restriction nodes. | |
| Node restrictionNode = null; | |
| boolean isListOrUnionNode = false; | |
| restrictionNode = CSchemaUtils.getListOrUnionNode(node); | |
| if (restrictionNode != null) | |
| isListOrUnionNode = true; | |
| if (!isListOrUnionNode) | |
| { | |
| NodeList children = node.getChildNodes(); | |
| for (int j = 0; j < children.getLength() && restrictionNode == null; j++) | |
| { | |
| QName restrictionKind = Utils.getNodeQName(children.item(j)); | |
| if (restrictionKind != null && | |
| restrictionKind.getLocalPart().equals("restriction") && | |
| Constants.isSchemaXSD(restrictionKind.getNamespaceURI())) | |
| restrictionNode = children.item(j); | |
| } | |
| } | |
| // If no restriction or union or list node, just return | |
| if (restrictionNode == null) | |
| return; | |
| // The restriction node indicates the type being restricted | |
| // (the base attribute contains this type). For list or union types, | |
| // treat as xsd:string. | |
| QName baseType; | |
| if (!isListOrUnionNode) | |
| baseType = Utils.getTypeQName(restrictionNode, new BooleanHolder(), false); | |
| else | |
| baseType = new QName("http://www.w3.org/2001/XMLSchema", "string"); | |
| TypeEntry baseEType = c_symbolTable.getType(baseType); | |
| if (baseEType != null) | |
| { | |
| QName typedataQName = typedata.getName(); | |
| String typedataLocalpart = typedataQName.getLocalPart(); | |
| String baseTypeLocalpart = baseEType.getQName().getLocalPart(); | |
| QName typedataQNameSanitized = null; | |
| String typedataLocalpartSanitized = null; | |
| String baseTypeLocalpartSanitized = null; | |
| String methodSuffix = null; | |
| String primitiveXSDType = null; | |
| String initValueForType = null; | |
| String classForPrimitiveType = null; | |
| if (TypeMap.isAnonymousType(typedataLocalpart)) | |
| { | |
| typedataQNameSanitized = new QName(typedataQName.getNamespaceURI(), CUtils.sanitizeString(typedataLocalpart)); | |
| typedataLocalpartSanitized = CUtils.sanitizeString(typedataLocalpart); | |
| } | |
| if (TypeMap.isAnonymousType(baseTypeLocalpart)) | |
| baseTypeLocalpartSanitized = CUtils.sanitizeString(baseTypeLocalpart); | |
| String class4qname = null; | |
| String class4qnameSanitized = null; | |
| String javaName = CUtils.getPrimitiveType(baseEType.getQName()); | |
| boolean isBaseTypePrimitive = javaName != null; | |
| QName primitiveBaseTypeQName = null; | |
| if (javaName == null) | |
| { | |
| // No mapping - ensure that the base type is simple - if it is, then this | |
| // must be a user-defined simple type that is based on another user-defined | |
| // simple type. | |
| if (!baseEType.isSimpleType() | |
| && !SchemaUtils.isSimpleSchemaType(baseEType.getQName())) | |
| return; | |
| // Get the primitive base type | |
| TypeEntry primitiveBaseType = CSchemaUtils.getBaseType(baseEType, c_symbolTable); | |
| primitiveBaseTypeQName = primitiveBaseType.getQName(); | |
| } | |
| else if (javaName.equals("boolean")) | |
| return; | |
| else | |
| primitiveBaseTypeQName = baseEType.getQName(); | |
| classForPrimitiveType = CUtils.getSimpleType(primitiveBaseTypeQName); | |
| initValueForType = CUtils.getInitValueForType(classForPrimitiveType); | |
| // Set the base type for Type | |
| typedata.setBaseType(primitiveBaseTypeQName); | |
| // We will map the user-defined type to the user-defined type, so set | |
| // mapping for the type. | |
| class4qname = typedataLocalpart; | |
| class4qnameSanitized = typedataLocalpartSanitized; | |
| // Update some commonly-used mapping tables to reflect the user-defined | |
| // simple type. If anonymous type, we need to update mapping tables twice: once | |
| // with the anonymous names, and once with the sanitized names. | |
| boolean isPointerType = CUtils.isPointerType(primitiveBaseTypeQName); | |
| primitiveXSDType = CUtils.getXSDEnumeratorForType(classForPrimitiveType); | |
| if (!isBaseTypePrimitive) | |
| { | |
| typedata.setRestrictionBaseType(baseTypeLocalpart); | |
| if (isPointerType) | |
| CUtils.addPointerType(baseTypeLocalpart); | |
| } | |
| if (isPointerType) | |
| CUtils.addPointerType(typedataLocalpart); | |
| methodSuffix = (String)CUtils.getDeserializerMethodSuffixForType(classForPrimitiveType); | |
| CUtils.addXSDEnumeratorForType(typedataLocalpart, primitiveXSDType); | |
| if (initValueForType != null) | |
| CUtils.addInitValueForType(typedataLocalpart, initValueForType); | |
| CUtils.addDeserializerMethodSuffixForType(typedataLocalpart, methodSuffix); | |
| if (!isBaseTypePrimitive) | |
| { | |
| CUtils.addXSDEnumeratorForType(baseTypeLocalpart, primitiveXSDType); | |
| if (initValueForType != null) | |
| CUtils.addInitValueForType(baseTypeLocalpart, initValueForType); | |
| CUtils.addDeserializerMethodSuffixForType(baseTypeLocalpart, methodSuffix); | |
| } | |
| if (typedataQNameSanitized != null) | |
| { | |
| if (isPointerType) | |
| CUtils.addPointerType(typedataLocalpartSanitized); | |
| CUtils.addXSDEnumeratorForType(typedataLocalpartSanitized, primitiveXSDType); | |
| if (initValueForType != null) | |
| CUtils.addInitValueForType(typedataLocalpartSanitized, initValueForType); | |
| CUtils.addDeserializerMethodSuffixForType(typedataLocalpartSanitized, methodSuffix); | |
| } | |
| if (baseTypeLocalpartSanitized != null) | |
| { | |
| if (isPointerType) | |
| CUtils.addPointerType(baseTypeLocalpartSanitized); | |
| CUtils.addXSDEnumeratorForType(baseTypeLocalpartSanitized, primitiveXSDType); | |
| if (initValueForType != null) | |
| CUtils.addInitValueForType(baseTypeLocalpartSanitized, initValueForType); | |
| CUtils.addDeserializerMethodSuffixForType(baseTypeLocalpartSanitized, methodSuffix); | |
| } | |
| // Process the enumeration elements underneath the restriction node | |
| Vector v = new Vector(); | |
| if (!isListOrUnionNode) | |
| { | |
| NodeList enums = restrictionNode.getChildNodes(); | |
| for (int i=0; i < enums.getLength(); i++) | |
| { | |
| QName enumKind = Utils.getNodeQName(enums.item(i)); | |
| if (enumKind != null && Constants.isSchemaXSD(enumKind.getNamespaceURI())) | |
| { | |
| Node enumNode = enums.item(i); | |
| String value = Utils.getAttribute(enumNode, "value"); | |
| if (value.indexOf(':')>0) | |
| value=value.substring(value.indexOf(':')+1,value.length()); | |
| v.add(new QName(value, enumKind.getLocalPart())); | |
| } | |
| } | |
| } | |
| // The first element in the vector is a TypeEntry. | |
| v.add(0,baseEType); | |
| typedata.setRestrictiondata(v); | |
| typedata.setRestriction(true); | |
| // Add schema-defined simple type to mapping table - TODO: not sure we need this anymore. | |
| CUtils.addSchemaDefinedSimpleType(typedataQName, class4qname); | |
| if (typedataQNameSanitized != null) | |
| CUtils.addSchemaDefinedSimpleType(typedataQNameSanitized, class4qnameSanitized); | |
| } | |
| } | |
| return; | |
| } | |
| /** | |
| * Work out the various conditions that dictate whether this type will be generated into a new | |
| * file or not. | |
| * This method is only very partially implemented. | |
| * | |
| * @param type | |
| * @param typedata | |
| * @return true if the type will not be generated. False otherwise | |
| */ | |
| private boolean isTypeGenerated(TypeEntry type, Type typedata) | |
| { | |
| // If the referenced type is actually a type that will not get generated because it's | |
| // a base type array then tell other people of this case. Do this to two levels of indirection | |
| if(type.getRefType()!=null) | |
| if(type.getRefType().getRefType()!=null && type.getRefType().getRefType().isBaseType()) | |
| return false; | |
| if (typedata.isAnonymous()) | |
| return false; | |
| else | |
| return true; | |
| } | |
| /** | |
| * Process service operations, generating information about each operation. | |
| * | |
| * @param bindingEntry | |
| * @return array of MethodInfo objects. | |
| * @throws WrapperFault | |
| */ | |
| public ArrayList processServiceMethods(BindingEntry bindingEntry, | |
| boolean wsdlWrappingStyle, | |
| boolean userRequestedWSDLWrappingStyle) throws WrapperFault | |
| { | |
| PortType portType = bindingEntry.getBinding().getPortType(); | |
| if (portType == null) | |
| throw new WrapperFault("Port type specified in binding '" + bindingEntry.getBinding().getQName().getLocalPart() + "' not found"); | |
| ArrayList serviceMethods = new ArrayList(); | |
| //get operation list | |
| Iterator oplist = portType.getOperations().iterator(); | |
| while (oplist.hasNext()) | |
| { | |
| Operation op = (Operation) oplist.next(); | |
| MethodInfo minfo = new MethodInfo(op.getName()); | |
| // This chunk of code is new and we hope to use it more in the future to replace some of the | |
| // things we do to process parameters. | |
| // When getOperationParameters() is called, the code, assuming user did not request unwrapped, | |
| // will determine whether the operation is eligible for wrapped-style. The bad thing is that | |
| // isWrapped() is a method on the SymbolTable class. So before processing an operation, | |
| // we call setWrapped(false) before calling getOperationParameters() so that we can determine | |
| // on a per-operation basis whether the operation is eligible for wrapped-style processing. | |
| c_symbolTable.setWrapped(false); | |
| Parameters opParams=null; | |
| try | |
| { | |
| opParams = c_symbolTable.getOperationParameters(op, "", bindingEntry); | |
| minfo.setOperationParameters(opParams); | |
| minfo.setEligibleForWrapped(c_symbolTable.isWrapped()); | |
| // mark the method as wrapped or unwrapped. | |
| if (!wsdlWrappingStyle || !minfo.isEligibleForWrapped()) | |
| { | |
| minfo.setIsUnwrapped(true); | |
| minfo.setConsumeBodyOnMessageValidation(false); | |
| } | |
| } | |
| catch (IOException e) | |
| { | |
| throw new WrapperFault(e); | |
| } | |
| if (c_verbose) | |
| { | |
| System.out.println("\n\n-----------------------------------------------"); | |
| System.out.println("Parameters for operation: " + op.getName()); | |
| System.out.println("-----------------------------------------------"); | |
| System.out.println(opParams); | |
| System.out.println("-----------------------------------------------"); | |
| } | |
| //setting the faults | |
| addFaultInfo(op.getFaults(), minfo); | |
| // process input and response messages | |
| if ("document".equals(bindingEntry.getBindingStyle().getName())) | |
| { | |
| if (userRequestedWSDLWrappingStyle && !minfo.isEligibleForWrapped()) | |
| System.out.println("INFORMATIONAL: Operation '" + op.getName() + "' is not eligible for wrapper-style, generating non-wrapper style."); | |
| addDocumentStyleInputMessageToMethodInfo(bindingEntry, op, minfo); | |
| addDocumentStyleOutputMessageToMethodInfo(bindingEntry, op, minfo); | |
| } | |
| else | |
| { | |
| addRPCStyleInputMessageToMethodInfo(bindingEntry, op, minfo); | |
| addRPCStyleOutputMessageToMethodInfo(bindingEntry, op, minfo); | |
| } | |
| //add operation to operation List | |
| serviceMethods.add(minfo); | |
| } | |
| // Need to get some stuff from binding element such as SOAPAction and namespace for | |
| // each operation - we store the information in the method. | |
| List operations = bindingEntry.getBinding().getBindingOperations(); | |
| if (operations != null) | |
| { | |
| for (int i = 0; i < operations.size(); i++) | |
| { | |
| //for the each binding operation found | |
| if (operations.get(i) instanceof javax.wsdl.BindingOperation) | |
| { | |
| javax.wsdl.BindingOperation bindinop = (javax.wsdl.BindingOperation) operations.get(i); | |
| String name = bindinop.getName(); | |
| MethodInfo method = null; | |
| for (int ii = 0; ii < serviceMethods.size(); ii++) | |
| if (((MethodInfo) serviceMethods.get(ii)).getMethodname().equals(name)) | |
| method = (MethodInfo) serviceMethods.get(ii); | |
| if (method == null) | |
| throw new WrapperFault("The binding and portType elements do not match."); | |
| // Get binding operation information and store in method for later use. | |
| WSDLInfo.updateMethodInfoFromBinding(bindinop, method); | |
| } | |
| } | |
| } | |
| return serviceMethods; | |
| } | |
| /** | |
| * @param op | |
| * @param minfo MethodInfo object into which output message and it's elements are to be added | |
| * @throws WrapperFault | |
| */ | |
| private void addRPCStyleOutputMessageToMethodInfo(BindingEntry bindingEntry, Operation op, MethodInfo minfo) throws WrapperFault | |
| { | |
| if (op.getOutput() == null) | |
| return; | |
| ParameterInfo pinfo; | |
| Iterator returnlist; | |
| minfo.setInputMessage(op.getInput().getMessage().getQName()); | |
| minfo.setOutputMessage(op.getOutput().getMessage().getQName()); | |
| if (op.getParameterOrdering() != null) | |
| { | |
| for (int ix = 0; ix < op.getParameterOrdering().size(); ix++) | |
| { | |
| Part p = (Part) (op.getOutput().getMessage().getParts().get((String) op.getParameterOrdering().get(ix))); | |
| if (p == null) | |
| continue; | |
| pinfo = createParameterInfo(p); | |
| if (null != pinfo) | |
| minfo.addOutputParameter(pinfo); | |
| } | |
| // TODO recheck parameter ordering logic.... | |
| // there can be more output parameters than in parameterOrder list (partial parameter ordering) | |
| returnlist = op.getOutput().getMessage().getParts().values().iterator(); | |
| while (returnlist.hasNext()) | |
| { | |
| //RPC style messages can have multiple parts | |
| Part p = (Part) returnlist.next(); | |
| if (op.getParameterOrdering().contains(p.getName()) | |
| || (bindingEntry.isOutHeaderPart(op.getName(), p.getName()))) | |
| continue; | |
| pinfo = createParameterInfo(p); | |
| if (null != pinfo) | |
| minfo.addOutputParameter(pinfo); | |
| } | |
| } | |
| else | |
| { | |
| returnlist = op.getOutput().getMessage().getParts().values().iterator(); | |
| while (returnlist.hasNext()) | |
| { | |
| //RPC style messages can have multiple parts | |
| Part p = ((Part) returnlist.next()); | |
| if (bindingEntry.isOutHeaderPart(op.getName(), p.getName())) | |
| continue; | |
| pinfo = createParameterInfo(p); | |
| if (null != pinfo) | |
| minfo.addOutputParameter(pinfo); | |
| } | |
| } | |
| } | |
| /** | |
| * @param minfo MethodInfo object into which output message and it's elements are to be added | |
| * @param part | |
| * @throws WrapperFault | |
| */ | |
| private void addDocumentStyleOutputMessageToMethodInfo(BindingEntry bindingEntry, Operation op, MethodInfo minfo) throws WrapperFault | |
| { | |
| if (op.getOutput() == null) | |
| return; | |
| Part part = null; | |
| // For now, skip over soap header parts | |
| Iterator returnlist = op.getOutput().getMessage().getParts().values().iterator(); | |
| while (returnlist.hasNext()) | |
| { | |
| part = (Part) returnlist.next(); | |
| if (bindingEntry.isOutHeaderPart(op.getName(), part.getName())) | |
| part = null; | |
| else | |
| break; | |
| } | |
| // If no output parameter, simply return. | |
| if (part == null) | |
| return; | |
| QName qname; | |
| QName minfoqname; | |
| TypeEntry elementTypeEntry; | |
| Element element = c_symbolTable.getElement(part.getElementName()); | |
| if (element == null) | |
| { | |
| elementTypeEntry = c_symbolTable.getType(part.getTypeName()); | |
| qname = elementTypeEntry.getQName(); | |
| minfoqname = elementTypeEntry.getQName(); | |
| } | |
| else | |
| { | |
| elementTypeEntry = element.getRefType(); | |
| qname = elementTypeEntry.getQName(); | |
| minfoqname = element.getQName(); | |
| } | |
| minfo.setOutputMessage(minfoqname); | |
| if (qname == null) | |
| return; | |
| Type type = c_typeMap.getType(qname); | |
| if (type == null) | |
| throw new WrapperFault("Unregistered type " + qname + " referenced!"); | |
| // TODO - need to look into this more. | |
| // For wrapped style, inner attributes and elements are added as parameters. | |
| // For unwrapped style, objects are used for the parameters (i.e. classes or structures). | |
| Iterator elementNames = type.getElementnames(); | |
| Iterator attributes = type.getAttributes(); | |
| if (!minfo.isUnwrapped()) | |
| { | |
| if (!elementNames.hasNext()) | |
| { | |
| // Type must be simple or primitive...we do a check just to make sure. | |
| if (type.isSimpleType() || type.isPrimitiveType()) | |
| { | |
| String elementName = (String) element.getQName().getLocalPart(); | |
| ParameterInfo pinfo = new ParameterInfo(); | |
| pinfo.setType(type); | |
| pinfo.setParamName(elementName, c_typeMap); | |
| pinfo.setElementName(element.getQName()); | |
| pinfo.setAnyElement(type.isAnyElement()); | |
| minfo.addOutputParameter(pinfo); | |
| minfo.setConsumeBodyOnMessageValidation(false); | |
| } | |
| } | |
| else | |
| { | |
| while (elementNames.hasNext()) | |
| { | |
| String elementname = (String) elementNames.next(); | |
| CElementDecl eleinfo = type.getElementForElementName(elementname); | |
| Type innerType = eleinfo.getType(); | |
| ParameterInfo pinfo = new ParameterInfo(); | |
| pinfo.setType(innerType); | |
| pinfo.setParamName(elementname, c_typeMap); | |
| pinfo.setArray(eleinfo.getMaxOccurs() > 1); | |
| pinfo.setNillable(eleinfo.isNillable()); | |
| pinfo.setOptional(eleinfo.getMinOccurs() == 0); | |
| pinfo.setElementName(type.getElementForElementName(elementname).getName()); | |
| pinfo.setAnyElement(innerType.isAnyElement()); | |
| minfo.addOutputParameter(pinfo); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| // Ensure there is a response, if not, then operation is a one-way operation. | |
| if (type.isSimpleType() | |
| || type.isPrimitiveType() | |
| || elementNames.hasNext() | |
| || (attributes != null && attributes.hasNext())) | |
| { | |
| String elementName = (String) element.getQName().getLocalPart(); | |
| ParameterInfo pinfo = new ParameterInfo(); | |
| pinfo.setType(type); | |
| type.setIsUnwrappedOutputType(true); | |
| pinfo.setParamName(elementName, c_typeMap); | |
| if (element != null) | |
| pinfo.setElementName(element.getQName()); | |
| else | |
| pinfo.setElementName(type.getName()); | |
| pinfo.setAnyElement(type.isAnyElement()); | |
| // Let us be nice and uppercase the first character in type name, | |
| // in addition to resolving method name/type conflicts. | |
| type.setLanguageSpecificName(generateNewTypeName(type, minfo)); | |
| minfo.addOutputParameter(pinfo); | |
| } | |
| else if (!elementNames.hasNext()) | |
| { | |
| // empty element....check message response but no deserialization necessary | |
| minfo.setConsumeBodyOnMessageValidation(true); | |
| } | |
| } | |
| } | |
| /** | |
| * @param op | |
| * @param minfo | |
| * @throws WrapperFault | |
| */ | |
| private void addRPCStyleInputMessageToMethodInfo(BindingEntry bindingEntry, Operation op, MethodInfo minfo) | |
| throws WrapperFault | |
| { | |
| ParameterInfo pinfo; | |
| Iterator paramlist; | |
| minfo.setInputMessage(op.getInput().getMessage().getQName()); | |
| if (op.getParameterOrdering() != null) | |
| { | |
| for (int ix = 0; ix < op.getParameterOrdering().size(); ix++) | |
| { | |
| Part p = (Part) (op.getInput() | |
| .getMessage() | |
| .getParts() | |
| .get((String) op.getParameterOrdering().get(ix))); | |
| if (p == null | |
| || bindingEntry.isInHeaderPart(op.getName(), p.getName())) | |
| continue; | |
| pinfo = createParameterInfo(p); | |
| if (null != pinfo) | |
| minfo.addInputParameter(pinfo); | |
| } | |
| } | |
| else | |
| { | |
| paramlist = op.getInput().getMessage().getParts().values().iterator(); | |
| while (paramlist.hasNext()) | |
| { | |
| //RPC style messages can have multiple parts | |
| Part p = (Part) paramlist.next(); | |
| if (bindingEntry.isInHeaderPart(op.getName(), p.getName())) | |
| continue; | |
| pinfo = createParameterInfo(p); | |
| if (null != pinfo) | |
| minfo.addInputParameter(pinfo); | |
| } | |
| } | |
| } | |
| /** | |
| * @param op | |
| * @param minfo | |
| * @throws WrapperFault | |
| */ | |
| private void addDocumentStyleInputMessageToMethodInfo(BindingEntry bindingEntry, Operation op, MethodInfo minfo) | |
| throws WrapperFault | |
| { | |
| Part part = null; | |
| // For now, skip over soap header parts. | |
| Iterator paramlist = op.getInput().getMessage().getParts().values().iterator(); | |
| while (paramlist.hasNext()) | |
| { | |
| part = (Part) paramlist.next(); | |
| if (bindingEntry.isInHeaderPart(op.getName(), part.getName())) | |
| part = null; | |
| else | |
| break; | |
| } | |
| // If no input parameter, simply return. | |
| if (part == null) | |
| return; | |
| QName minfoqname; | |
| QName qname; | |
| Element element = c_symbolTable.getElement(part.getElementName()); | |
| if (element == null) | |
| { | |
| // the part reference a type. | |
| qname = c_symbolTable.getType(part.getTypeName()).getQName(); | |
| minfoqname = c_symbolTable.getType(part.getTypeName()).getQName(); | |
| } | |
| else | |
| { | |
| qname = element.getRefType().getQName(); | |
| minfoqname = element.getQName(); | |
| } | |
| minfo.setInputMessage(minfoqname); | |
| if (qname == null) | |
| return; | |
| Type type = c_typeMap.getType(qname); | |
| if (type == null) | |
| throw new WrapperFault("unregistered type " + qname + " referenced"); | |
| // For wrapped style, inner attributes and elements are added as parameters. | |
| // For unwrapped style, objects are used for the parameters (i.e. classes or structures). | |
| Iterator elementNames = type.getElementnames(); | |
| Iterator attributes = type.getAttributes(); | |
| if (!minfo.isUnwrapped()) | |
| { | |
| // Add input elements to method info | |
| while (elementNames.hasNext()) | |
| { | |
| String elementname = (String) elementNames.next(); | |
| CElementDecl eleinfo = type.getElementForElementName(elementname); | |
| Type innerType = eleinfo.getType(); | |
| ParameterInfo pinfo = new ParameterInfo(); | |
| pinfo.setType(innerType); | |
| pinfo.setParamName(elementname, c_typeMap); | |
| pinfo.setArray(eleinfo.getMaxOccurs() > 1); | |
| pinfo.setElementName(type.getElementForElementName(elementname).getName()); | |
| pinfo.setAnyElement(innerType.isAnyElement()); | |
| pinfo.setNillable(eleinfo.isNillable()); | |
| pinfo.setOptional(eleinfo.getMinOccurs() == 0); | |
| minfo.addInputParameter(pinfo); | |
| } | |
| // add input attributes to method info - TODO probably can remove this chunk of code. | |
| if (attributes != null) | |
| { | |
| while (attributes.hasNext()) | |
| { | |
| CContainedAttribute attr = (CContainedAttribute)attributes.next(); | |
| ParameterInfo pinfo = new ParameterInfo(); | |
| pinfo.setType(attr.getType()); | |
| pinfo.setParamName(attr.getName(), c_typeMap); | |
| pinfo.setElementName(attr.getType().getName()); | |
| pinfo.setAttribute(true); | |
| minfo.addInputParameter(pinfo); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| // If input element is complex and does not contain any sub-elements or attributes, we ignore. | |
| if (type.isSimpleType() | |
| || type.isPrimitiveType() | |
| || elementNames.hasNext() | |
| || (attributes != null && attributes.hasNext())) | |
| { | |
| String elementName; | |
| if (element != null) | |
| elementName = element.getQName().getLocalPart(); | |
| else | |
| elementName = type.getName().getLocalPart(); | |
| ParameterInfo pinfo = new ParameterInfo(); | |
| pinfo.setType(type); | |
| type.setIsUnwrappedInputType(true); | |
| pinfo.setParamName(elementName, c_typeMap); | |
| if (element != null) | |
| pinfo.setElementName(element.getQName()); | |
| else | |
| pinfo.setElementName(type.getName()); | |
| pinfo.setAnyElement(type.isAnyElement()); | |
| // Let us be nice and uppercase the first character in type name, | |
| // in addition to resolving method name/type conflicts. | |
| type.setLanguageSpecificName(generateNewTypeName(type, minfo)); | |
| minfo.addInputParameter(pinfo); | |
| } | |
| } | |
| } | |
| /** | |
| * Adds faults. | |
| * | |
| * @param faults | |
| * @param methodinfo | |
| * @throws WrapperFault | |
| */ | |
| private void addFaultInfo(Map faults, MethodInfo methodinfo) | |
| throws WrapperFault | |
| { | |
| if (faults == null) | |
| return; | |
| Iterator faultIt = faults.values().iterator(); | |
| while (faultIt.hasNext()) | |
| { | |
| Fault fault = (Fault) faultIt.next(); | |
| FaultInfo faultinfo = new FaultInfo(fault.getName()); | |
| Map parts = fault.getMessage().getParts(); | |
| Iterator partIt = parts.values().iterator(); | |
| while (partIt.hasNext()) | |
| { | |
| ParameterInfo pinfo = createParameterInfo((Part) partIt.next()); | |
| pinfo.getType().setAsFault(true); | |
| faultinfo.addParam(pinfo); | |
| } | |
| methodinfo.addFaultType(faultinfo); | |
| } | |
| } | |
| /** | |
| * | |
| * @param part | |
| * @return | |
| * @throws WrapperFault | |
| */ | |
| private ParameterInfo createParameterInfo(Part part) throws WrapperFault | |
| { | |
| QName qname = part.getTypeName(); | |
| if (qname == null) | |
| { | |
| Element element = c_symbolTable.getElement(part.getElementName()); | |
| qname = element.getRefType().getQName(); | |
| } | |
| Type type = c_typeMap.getType(qname); | |
| if (type == null) | |
| throw new WrapperFault("unregistered type " + qname + " referred"); | |
| ParameterInfo pinfo = new ParameterInfo(); | |
| pinfo.setType(type); | |
| pinfo.setParamName(part.getName(), c_typeMap); | |
| pinfo.setElementName(part.getElementName()); | |
| return pinfo; | |
| } | |
| /** | |
| * Resolves name conflict between a method name and a type name. | |
| * When doing document-literal, usually the name of the wrapper element is same as the | |
| * operation name. | |
| * | |
| * @param type | |
| * @param minfo | |
| * @return the new type name that does not conflict with the operation name. | |
| */ | |
| private String generateNewTypeName(Type type, MethodInfo minfo) | |
| { | |
| String minfo_nm = minfo.getMethodname(); | |
| String type_nm = type.getLanguageSpecificName(); | |
| if (CUtils.isPrimitiveType(type_nm)) | |
| return type_nm; | |
| String newName = CUtils.capitalizeFirstCharacter(type_nm); | |
| if (!minfo_nm.equals(newName)) | |
| return newName; | |
| return newName + "_t"; | |
| } | |
| /** | |
| * Checks if binding entry is SOAP and specified version. | |
| * @param be | |
| * @return | |
| */ | |
| private static boolean isSOAPBinding(BindingEntry be, String soapNamespace) | |
| { | |
| Binding b = be.getBinding(); | |
| if ((be.getBindingType() == BindingEntry.TYPE_SOAP)) | |
| { | |
| String ns = soapNamespace; | |
| SOAPBinding soapbinding = (SOAPBinding)getExtensibilityElement(b, INSTANCEOF_SOAPBINDING); | |
| if (soapbinding != null && null != soapbinding.getElementType().getNamespaceURI()) | |
| ns = soapbinding.getElementType().getNamespaceURI(); | |
| return ns.equals(soapNamespace); | |
| } | |
| return false; | |
| } | |
| } |