| /* |
| * Copyright 2001-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.symbolTable; |
| |
| import org.apache.axis.Constants; |
| import org.apache.axis.utils.JavaUtils; |
| import org.w3c.dom.DOMException; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| |
| import javax.xml.namespace.QName; |
| import javax.xml.rpc.holders.BooleanHolder; |
| import javax.xml.rpc.holders.IntHolder; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.Set; |
| import java.util.StringTokenizer; |
| import java.util.Vector; |
| /** |
| * This class contains static utility methods specifically for schema type queries. |
| * |
| * @author Rich Scheuerle (scheu@us.ibm.com) |
| */ |
| public class CSchemaUtils extends SchemaUtils |
| { |
| |
| /** Field VALUE_QNAME */ |
| static final QName VALUE_QNAME = Utils.findQName("", "value"); |
| |
| /** |
| * This method checks mixed=true attribute is set either on |
| * complexType or complexContent element. |
| */ |
| public static boolean isMixed(Node node) |
| { |
| // Expecting a schema complexType |
| if (isXSDNode(node, "complexType")) |
| { |
| String mixed = ((Element) node).getAttribute("mixed"); |
| if (mixed != null && mixed.length() > 0) |
| { |
| return ("true".equalsIgnoreCase(mixed) || "1".equals(mixed)); |
| } |
| // Under the complexType there could be complexContent with |
| // mixed="true" |
| NodeList children = node.getChildNodes(); |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| if (isXSDNode(kid, "complexContent")) |
| { |
| mixed = ((Element) kid).getAttribute("mixed"); |
| return ("true".equalsIgnoreCase(mixed) || "1".equals(mixed)); |
| } |
| } |
| } |
| return false; |
| } |
| |
| public static Node getUnionNode(Node node) |
| { |
| // Expecting a schema complexType |
| if (isXSDNode(node, "simpleType")) |
| { |
| // Under the simpleType there could be union |
| NodeList children = node.getChildNodes(); |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| if (isXSDNode(kid, "union")) |
| return kid; |
| } |
| } |
| return null; |
| } |
| |
| public static Node getListNode(Node node) |
| { |
| // Expecting a schema simpleType |
| if (isXSDNode(node, "simpleType")) |
| { |
| // Under the simpleType there could be list |
| NodeList children = node.getChildNodes(); |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| if (isXSDNode(kid, "list")) |
| return kid; |
| } |
| } |
| return null; |
| } |
| |
| public static boolean isSimpleTypeWithUnion(Node node) |
| { |
| return (getUnionNode(node) != null); |
| } |
| |
| /** |
| * This method checks out if the given node satisfies the 3rd condition |
| * of the "wrapper" style: |
| * such an element (a wrapper) must be of a complex type defined using the |
| * xsd:sequence compositor and containing only elements declarations. |
| * (excerpt from JAX-RPC spec 1.1 Maintenanace Review 2 Chapter 6 Section 4.1.) |
| * |
| * @param node |
| * @return |
| */ |
| public static boolean isWrappedType(Node node) |
| { |
| |
| if (node == null) |
| return false; |
| |
| // If the node kind is an element, dive into it. |
| if (isXSDNode(node, "element")) |
| { |
| NodeList children = node.getChildNodes(); |
| boolean hasComplexType = false; |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| if (isXSDNode(kid, "complexType")) |
| { |
| node = kid; |
| hasComplexType = true; |
| break; |
| } |
| } |
| |
| if (!hasComplexType) |
| return false; |
| } |
| |
| // Expecting a schema complexType |
| if (isXSDNode(node, "complexType")) |
| { |
| // Under the complexType there could be complexContent/simpleContent |
| // and extension elements if this is a derived type. |
| // A wrapper element must be complex-typed. |
| |
| NodeList children = node.getChildNodes(); |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexContent")) |
| return false; |
| else if (isXSDNode(kid, "simpleContent")) |
| return false; |
| } |
| |
| // Under the complexType there may be choice, sequence, group and/or all nodes. |
| // (There may be other #text nodes, which we will ignore). |
| // The complex type of a wrapper element must have only sequence |
| // and again element declarations in the sequence. |
| children = node.getChildNodes(); |
| int len = children.getLength(); |
| for (int j = 0; j < len; j++) |
| { |
| Node kid = children.item(j); |
| String localName = kid.getLocalName(); |
| if (localName != null && Constants.isSchemaXSD(kid.getNamespaceURI())) |
| { |
| if (localName.equals("sequence")) |
| { |
| Node sequenceNode = kid; |
| NodeList sequenceChildren = sequenceNode.getChildNodes(); |
| int sequenceLen = sequenceChildren.getLength(); |
| for (int k = 0; k < sequenceLen; k++) |
| { |
| Node sequenceKid = sequenceChildren.item(k); |
| String sequenceLocalName = sequenceKid.getLocalName(); |
| if (sequenceLocalName != null && |
| Constants.isSchemaXSD(sequenceKid.getNamespaceURI())) |
| { |
| // allow choice with element children |
| if (sequenceLocalName.equals("choice")) |
| { |
| Node choiceNode = sequenceKid; |
| NodeList choiceChildren = choiceNode.getChildNodes(); |
| int choiceLen = choiceChildren.getLength(); |
| for (int l = 0; l < choiceLen; l++) |
| { |
| Node choiceKid = choiceChildren.item(l); |
| String choiceLocalName = choiceKid.getLocalName(); |
| if (choiceLocalName != null && |
| Constants.isSchemaXSD(choiceKid.getNamespaceURI())) |
| { |
| if (!choiceLocalName.equals("element")) |
| return false; |
| } |
| } |
| } |
| else if (!sequenceLocalName.equals("element")) |
| return false; |
| } |
| } |
| return true; |
| } |
| else |
| return false; |
| } |
| } |
| } |
| // allows void type |
| return true; |
| } |
| |
| /** |
| * If the specified node represents a supported JAX-RPC complexType or |
| * simpleType, a Vector is returned which contains ElementDecls for the |
| * child element names. |
| * If the element is a simpleType, an ElementDecls is built representing |
| * the restricted type with the special name "value". |
| * If the element is a complexType which has simpleContent, an ElementDecl |
| * is built representing the extended type with the special name "value". |
| * This method does not return attribute names and types |
| * (use the getContainedAttributeTypes) |
| * If the specified node is not a supported |
| * JAX-RPC complexType/simpleType/element null is returned. |
| * |
| * @param node |
| * @param symbolTable |
| * @return |
| */ |
| public static Vector getContainedElementDeclarations(Node node, |
| SymbolTable symbolTable) { |
| if (node == null) |
| return null; |
| |
| // If the node kind is an element, dive into it. |
| if (isXSDNode(node, "element")) |
| { |
| NodeList children = node.getChildNodes(); |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexType")) |
| { |
| node = kid; |
| break; |
| } |
| } |
| } |
| |
| // Expecting a schema complexType or simpleType |
| if (isXSDNode(node, "complexType")) |
| { |
| |
| // Under the complexType there could be complexContent/simpleContent |
| // and extension elements if this is a derived type. Skip over these. |
| NodeList children = node.getChildNodes(); |
| Node complexContent = null; |
| Node simpleContent = null; |
| Node extension = null; |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexContent")) |
| { |
| complexContent = kid; |
| break; // REMIND: should this be here or on either branch? |
| } |
| else if (isXSDNode(kid, "simpleContent")) |
| simpleContent = kid; |
| } |
| |
| if (complexContent != null) |
| { |
| children = complexContent.getChildNodes(); |
| |
| for (int j = 0; (j < children.getLength()) && (extension == null); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "extension") || isXSDNode(kid, "restriction")) |
| extension = kid; |
| } |
| } |
| |
| if (simpleContent != null) |
| { |
| children = simpleContent.getChildNodes(); |
| |
| int len = children.getLength(); |
| for (int j = 0; (j < len) && (extension == null); j++) |
| { |
| Node kid = children.item(j); |
| String localName = kid.getLocalName(); |
| |
| if ((localName != null) |
| && (localName.equals("extension") || localName.equals("restriction")) |
| && Constants.isSchemaXSD(kid.getNamespaceURI())) |
| { |
| |
| // get the type of the extension/restriction from the "base" attribute |
| QName extendsOrRestrictsTypeName = |
| Utils.getTypeQName(children.item(j), new BooleanHolder(), false); |
| |
| TypeEntry extendsOrRestrictsType = |
| symbolTable.getTypeEntry(extendsOrRestrictsTypeName, false); |
| |
| // If this type extends a simple type, then add the |
| // special "value" ElementDecl, else this type is |
| // extending another simpleContent type and will |
| // already have a "value". |
| |
| if (extendsOrRestrictsType == null || extendsOrRestrictsType.isBaseType()) |
| { |
| // Return an element declaration with a fixed name |
| // ("value") and the correct type. |
| Vector v = new Vector(); |
| CElementDecl elem = new CElementDecl(extendsOrRestrictsType, VALUE_QNAME); |
| v.add(elem); |
| |
| return v; |
| } |
| else |
| { |
| // There can't be any other elements in a |
| // simpleContent node. |
| return null; |
| } |
| } |
| } |
| } |
| |
| if (extension != null) |
| node = extension; // Skip over complexContent and extension |
| |
| // Under the complexType there may be choice, sequence, group and/or all nodes. |
| // (There may be other #text nodes, which we will ignore). |
| children = node.getChildNodes(); |
| |
| Vector v = new Vector(); |
| int len = children.getLength(); |
| for (int j = 0; j < len; j++) |
| { |
| Node kid = children.item(j); |
| String localName = kid.getLocalName(); |
| if (localName != null && Constants.isSchemaXSD(kid.getNamespaceURI())) |
| { |
| if (localName.equals("sequence")) |
| v.addAll(processSequenceNode(kid, symbolTable)); |
| else if (localName.equals("all")) |
| v.addAll(processAllNode(kid, symbolTable)); |
| else if (localName.equals("choice")) |
| v.addAll(processChoiceNode(kid, symbolTable)); |
| else if (localName.equals("group")) |
| v.addAll(processGroupNode(kid, symbolTable)); |
| } |
| } |
| |
| return v; |
| } |
| else if (isXSDNode(node, "group")) |
| { |
| /* |
| * Does this else clause make any sense anymore if |
| * we're treating refs to xs:groups like a macro inclusion |
| * into the referencing type? |
| * Maybe this else clause should never be possible? |
| * |
| NodeList children = node.getChildNodes(); |
| Vector v = new Vector(); |
| int len = children.getLength(); |
| for (int j = 0; j < len; j++) { |
| Node kid = children.item(j); |
| String localName = kid.getLocalName(); |
| if (localName != null && |
| Constants.isSchemaXSD(kid.getNamespaceURI())) { |
| if (localName.equals("sequence")) { |
| v.addAll(processSequenceNode(kid, symbolTable)); |
| } else if (localName.equals("all")) { |
| v.addAll(processAllNode(kid, symbolTable)); |
| } else if (localName.equals("choice")) { |
| v.addAll(processChoiceNode(kid, symbolTable)); |
| } |
| } |
| } |
| return v; |
| */ |
| return null; |
| } |
| else |
| { |
| // This may be a simpleType, return the type with the name "value" |
| QName[] simpleQName = getContainedSimpleTypes(node); |
| |
| if (simpleQName != null) |
| { |
| Vector v = null; |
| |
| for (int i = 0; i < simpleQName.length; i++) |
| { |
| TypeEntry simpleType = symbolTable.getType(simpleQName[i]); |
| |
| if (simpleType != null) |
| { |
| if (v == null) |
| v = new Vector(); |
| |
| QName qname = null; |
| if (simpleQName.length > 1) |
| qname = new QName("", simpleQName[i].getLocalPart() + "Value"); |
| else |
| qname = new QName("", "value"); |
| |
| v.add(new CElementDecl(simpleType, qname)); |
| } |
| } |
| |
| return v; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Invoked by getContainedElementDeclarations to get the child element types |
| * and child element names underneath a Choice Node |
| * |
| * @param choiceNode |
| * @param symbolTable |
| * @return |
| */ |
| private static Vector processChoiceNode(Node choiceNode, SymbolTable symbolTable) |
| { |
| Vector v = new Vector(); |
| NodeList children = choiceNode.getChildNodes(); |
| int len = children.getLength(); |
| for (int j = 0; j < len; j++) |
| { |
| Node kid = children.item(j); |
| String localName = kid.getLocalName(); |
| |
| if (localName != null && Constants.isSchemaXSD(kid.getNamespaceURI())) |
| { |
| if (localName.equals("choice")) |
| v.addAll(processChoiceNode(kid, symbolTable)); |
| else if (localName.equals("sequence")) |
| v.addAll(processSequenceNode(kid, symbolTable)); |
| else if (localName.equals("group")) |
| v.addAll(processGroupNode(kid, symbolTable)); |
| else if (localName.equals("element")) |
| { |
| CElementDecl elem = processChildElementNode(kid, symbolTable); |
| |
| if (elem != null) |
| { |
| elem.setChoiceElement(true); |
| v.add(elem); |
| } |
| } |
| else if (localName.equals("any")) |
| { |
| // Represent this as an element named any of type any type. |
| // This will cause it to be serialized with the element |
| // serializer. |
| TypeEntry type = symbolTable.getType(Constants.XSD_ANY); |
| CElementDecl elem = new CElementDecl(type, Utils.findQName("", "any")); |
| |
| elem.setAnyElement(true); |
| v.add(elem); |
| } |
| } |
| } |
| |
| return v; |
| } |
| |
| /** |
| * Returns named child node. |
| * |
| * @param parentNode Parent node. |
| * @param name Element name of child node to return. |
| */ |
| private static Node getChildByName(Node parentNode, String name) throws DOMException |
| { |
| if (parentNode == null) |
| return null; |
| |
| NodeList children = parentNode.getChildNodes(); |
| if (children != null) |
| { |
| for (int i = 0; i < children.getLength(); i++) |
| { |
| Node child = children.item(i); |
| if (child != null) |
| { |
| if ((child.getNodeName() != null && (name.equals(child.getNodeName()))) || |
| (child.getLocalName() != null && (name.equals(child.getLocalName())))) |
| return child; |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns all textual nodes of a subnode defined by a parent node |
| * and a path of element names to that subnode. |
| * |
| * @param root Parent node. |
| * @param path Path of element names to text of interest, delimited by "/". |
| */ |
| public static String getTextByPath(Node root, String path) throws DOMException |
| { |
| StringTokenizer st = new StringTokenizer(path, "/"); |
| Node node = root; |
| while (st.hasMoreTokens()) |
| { |
| String elementName = st.nextToken(); |
| Node child = getChildByName(node, elementName); |
| if (child == null) |
| throw new DOMException(DOMException.NOT_FOUND_ERR, "could not find " + elementName); |
| node = child; |
| } |
| |
| // should have found the node |
| String text = ""; |
| NodeList children = node.getChildNodes(); |
| if (children != null) |
| { |
| for (int i = 0; i < children.getLength(); i++) |
| { |
| Node child = children.item(i); |
| if (child != null) |
| { |
| if (child.getNodeName() != null |
| && (child.getNodeName().equals("#text") |
| || child.getNodeName().equals("#cdata-section"))) |
| { |
| text += child.getNodeValue(); |
| } |
| } |
| } |
| } |
| return text; |
| } |
| |
| /** |
| * Returns the complete text of the child xsd:annotation/xsd:documentation |
| * element from the provided node. Only the first annotation element and |
| * the first documentation element in the annotation element will be used. |
| * |
| * @param typeNode Parent node. |
| */ |
| public static String getAnnotationDocumentation(Node typeNode) |
| { |
| Node annotationNode = typeNode.getFirstChild(); |
| while (annotationNode != null) |
| { |
| if (isXSDNode(annotationNode, "annotation")) |
| break; |
| annotationNode = annotationNode.getNextSibling(); |
| } |
| Node documentationNode; |
| if (annotationNode != null) |
| { |
| documentationNode = annotationNode.getFirstChild(); |
| while (documentationNode != null) |
| { |
| if (isXSDNode(documentationNode, "documentation")) |
| break; |
| documentationNode = documentationNode.getNextSibling(); |
| } |
| } |
| else |
| documentationNode = null; |
| |
| // should have found the node if it exists |
| String text = ""; |
| if (documentationNode != null) |
| { |
| NodeList children = documentationNode.getChildNodes(); |
| if (children != null) |
| { |
| for (int i = 0; i < children.getLength(); i++) |
| { |
| Node child = children.item(i); |
| if (child != null) |
| { |
| if (child.getNodeName() != null |
| && (child.getNodeName().equals("#text") |
| || child.getNodeName().equals("#cdata-section"))) |
| { |
| text += child.getNodeValue(); |
| } |
| } |
| } |
| } |
| } |
| return text; |
| } |
| |
| /** |
| * Invoked by getContainedElementDeclarations to get the child element types |
| * and child element names underneath a Sequence Node |
| * |
| * @param sequenceNode |
| * @param symbolTable |
| * @return |
| */ |
| private static Vector processSequenceNode(Node sequenceNode, |
| SymbolTable symbolTable) |
| { |
| Vector v = new Vector(); |
| NodeList children = sequenceNode.getChildNodes(); |
| int len = children.getLength(); |
| for (int j = 0; j < len; j++) |
| { |
| Node kid = children.item(j); |
| String localName = kid.getLocalName(); |
| |
| if (localName != null && Constants.isSchemaXSD(kid.getNamespaceURI())) |
| { |
| if (localName.equals("choice")) |
| v.addAll(processChoiceNode(kid, symbolTable)); |
| else if (localName.equals("sequence")) |
| v.addAll(processSequenceNode(kid, symbolTable)); |
| else if (localName.equals("group")) |
| v.addAll(processGroupNode(kid, symbolTable)); |
| else if (localName.equals("any")) |
| { |
| // Represent this as an element named any of type any type. |
| // This will cause it to be serialized with the element |
| // serializer. |
| TypeEntry type = symbolTable.getType(Constants.XSD_ANY); |
| CElementDecl elem = new CElementDecl(type, Utils.findQName("", "any")); |
| |
| elem.setAnyElement(true); |
| v.add(elem); |
| } |
| else if (localName.equals("element")) |
| { |
| CElementDecl elem = processChildElementNode(kid, symbolTable); |
| |
| if (elem != null) |
| v.add(elem); |
| } |
| } |
| } |
| |
| return v; |
| } |
| |
| /** |
| * Invoked by getContainedElementDeclarations to get the child element types |
| * and child element names underneath a group node. If a ref attribute is |
| * specified, only the referenced group element is returned. |
| * |
| * @param groupNode |
| * @param symbolTable |
| * @return |
| */ |
| private static Vector processGroupNode(Node groupNode, SymbolTable symbolTable) |
| { |
| Vector v = new Vector(); |
| if (groupNode.getAttributes().getNamedItem("ref") == null) |
| { |
| NodeList children = groupNode.getChildNodes(); |
| int len = children.getLength(); |
| for (int j = 0; j < len; j++) |
| { |
| Node kid = children.item(j); |
| String localName = kid.getLocalName(); |
| if (localName != null && Constants.isSchemaXSD(kid.getNamespaceURI())) |
| { |
| if (localName.equals("choice")) |
| v.addAll(processChoiceNode(kid, symbolTable)); |
| else if (localName.equals("sequence")) |
| v.addAll(processSequenceNode(kid, symbolTable)); |
| else if (localName.equals("all")) |
| v.addAll(processAllNode(kid, symbolTable)); |
| } |
| } |
| } |
| else |
| { |
| QName nodeType = Utils.getTypeQName(groupNode, new BooleanHolder(), false); |
| |
| // The value of the second argument is 'false' since global model group |
| // definitions are always represented by objects whose type is |
| // assignment compatible with 'org.apache.axis.wsdl.symbolTable.Type'. |
| TypeEntry type = symbolTable.getTypeEntry(nodeType, false); |
| |
| if (type != null && type.getNode() != null) |
| { |
| Node node = type.getNode(); |
| NodeList children = node.getChildNodes(); |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| QName subNodeKind = Utils.getNodeQName(children.item(j)); |
| if ((subNodeKind != null) |
| && Constants.isSchemaXSD(subNodeKind.getNamespaceURI())) |
| { |
| if (subNodeKind.getLocalPart().equals("sequence")) |
| v.addAll(processSequenceNode(children.item(j), symbolTable)); |
| else if (subNodeKind.getLocalPart().equals("all")) |
| v.addAll(processAllNode(children.item(j), symbolTable)); |
| else if (subNodeKind.getLocalPart().equals("choice")) |
| v.addAll(processChoiceNode(children.item(j), symbolTable)); |
| } |
| } |
| } |
| } |
| return v; |
| } |
| |
| /** |
| * Invoked by getContainedElementDeclarations to get the child element types |
| * and child element names underneath an all node. |
| * |
| * @param allNode |
| * @param symbolTable |
| * @return |
| */ |
| private static Vector processAllNode(Node allNode, SymbolTable symbolTable) |
| { |
| |
| Vector v = new Vector(); |
| NodeList children = allNode.getChildNodes(); |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "element")) |
| { |
| CElementDecl elem = processChildElementNode(kid, symbolTable); |
| |
| if (elem != null) |
| { |
| elem.setAllElement(true); |
| v.add(elem); |
| } |
| } |
| } |
| |
| return v; |
| } |
| |
| /** |
| * Invoked by getContainedElementDeclarations to get the child element type |
| * and child element name for a child element node. |
| * <p/> |
| * If the specified node represents a supported JAX-RPC child element, |
| * we return an ElementDecl containing the child element name and type. |
| * |
| * @param elementNode |
| * @param symbolTable |
| * @return |
| */ |
| private static CElementDecl processChildElementNode(Node elementNode, |
| SymbolTable symbolTable) |
| { |
| // Get the name qnames. |
| QName nodeName = Utils.getNodeNameQName(elementNode); |
| BooleanHolder forElement = new BooleanHolder(); |
| String comments = null; |
| comments = getAnnotationDocumentation(elementNode); |
| |
| // The type qname is used to locate the TypeEntry, which is then |
| // used to retrieve the proper java name of the type. |
| QName nodeType = Utils.getTypeQName(elementNode, forElement, false); |
| TypeEntry type = symbolTable.getTypeEntry(nodeType, forElement.value); |
| |
| // We want to treat schema references same way we treat anyType. |
| if (type == null |
| && nodeType.getLocalPart().equals("schema") |
| && nodeType.getNamespaceURI().equals("http://www.w3.org/2001/XMLSchema")) |
| { |
| forElement.value = false; |
| type = symbolTable.getTypeEntry(nodeType, forElement.value); |
| } |
| |
| //The boolean field 'qualified' is set to true |
| //if the element is namespace qualified. |
| //The default value is unqualified. |
| boolean qualified = false; |
| |
| // An element inside a complex type is either qualified or unqualified. |
| // If the ref= attribute is used, the name of the ref'd element is used |
| // (which must be a root element). If the ref= attribute is not |
| // used, the name of the element is unqualified. |
| if (!forElement.value) |
| { |
| // check the Form (or elementFormDefault) attribute of this node to |
| // determine if it should be namespace quailfied or not. |
| String form = Utils.getAttribute(elementNode, "form"); |
| |
| if ((form != null) && form.equals("unqualified")) |
| nodeName = Utils.findQName("", nodeName.getLocalPart()); |
| else if ((form != null) && form.equals("qualified")) |
| qualified = true; |
| else if (form == null) |
| { |
| // check elementFormDefault on schema element |
| String def = Utils.getScopedAttribute(elementNode, "elementFormDefault"); |
| |
| if ((def == null) || def.equals("unqualified")) |
| nodeName = Utils.findQName("", nodeName.getLocalPart()); |
| else if ((def == null) || def.equals("qualified")) |
| qualified = true; |
| } |
| } |
| |
| if (type != null) |
| { |
| CElementDecl elem = new CElementDecl(type, nodeName); |
| elem.setDocumentation(comments); |
| |
| String minOccurs = Utils.getAttribute(elementNode, "minOccurs"); |
| if (minOccurs != null) { |
| elem.setMinOccurs(Integer.parseInt(minOccurs)); |
| } |
| |
| String maxOccurs = Utils.getAttribute(elementNode, "maxOccurs"); |
| if (maxOccurs != null) { |
| if (maxOccurs.equals("unbounded")) { |
| elem.setMaxOccurs(CElementDecl.UNBOUNDED); |
| } |
| else |
| elem.setMaxOccurs(Integer.parseInt(maxOccurs)); |
| } |
| |
| elem.setNillable(JavaUtils.isTrueExplicitly(Utils.getAttribute(elementNode, "nillable"))); |
| |
| String useValue = Utils.getAttribute(elementNode, "use"); |
| |
| if (useValue != null) |
| elem.setOptional(useValue.equalsIgnoreCase("optional")); |
| |
| elem.setNsQualified(qualified); |
| |
| return elem; |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns the WSDL2Java QName for the anonymous type of the element |
| * or null. |
| * |
| * @param node |
| * @return |
| */ |
| public static QName getElementAnonQName(Node node) |
| { |
| |
| if (isXSDNode(node, "element")) |
| { |
| NodeList children = node.getChildNodes(); |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexType") || isXSDNode(kid, "simpleType")) |
| return Utils.getNodeNameQName(kid); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns the WSDL2Java QName for the anonymous type of the attribute |
| * or null. |
| * |
| * @param node |
| * @return |
| */ |
| public static QName getAttributeAnonQName(Node node) |
| { |
| |
| if (isXSDNode(node, "attribute")) |
| { |
| NodeList children = node.getChildNodes(); |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexType") || isXSDNode(kid, "simpleType")) |
| return Utils.getNodeNameQName(kid); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * If the specified node is a simple type or contains simpleContent, return true |
| * |
| * @param node |
| * @return |
| */ |
| public static boolean isSimpleTypeOrSimpleContent(Node node) { |
| |
| if (node == null) |
| return false; |
| |
| // If the node kind is an element, dive into it. |
| if (isXSDNode(node, "element")) |
| { |
| NodeList children = node.getChildNodes(); |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexType")) |
| { |
| node = kid; |
| break; |
| } |
| else if (isXSDNode(kid, "simpleType")) |
| return true; |
| } |
| } |
| |
| // Expecting a schema complexType or simpleType |
| if (isXSDNode(node, "simpleType")) |
| return true; |
| |
| if (isXSDNode(node, "complexType")) |
| { |
| // Under the complexType there could be complexContent/simpleContent |
| // and extension elements if this is a derived type. Skip over these. |
| NodeList children = node.getChildNodes(); |
| Node complexContent = null; |
| Node simpleContent = null; |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexContent")) |
| { |
| complexContent = kid; |
| break; |
| } |
| else if (isXSDNode(kid, "simpleContent")) |
| simpleContent = kid; |
| } |
| |
| if (complexContent != null) |
| return false; |
| |
| if (simpleContent != null) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Test whether <tt>node</tt> is not null, belongs to the XML |
| * Schema namespace, and has a localName that matches |
| * <tt>schemaLocalName</tt> |
| * <p/> |
| * This can be used to determine that a given Node defines a |
| * schema "complexType" "element" and so forth. |
| * |
| * @param node a <code>Node</code> value |
| * @param schemaLocalName a <code>String</code> value |
| * @return true if the node is matches the name in the schema namespace. |
| */ |
| private static boolean isXSDNode(Node node, String schemaLocalName) |
| { |
| if (node == null) |
| return false; |
| |
| String localName = node.getLocalName(); |
| if (localName == null) |
| return false; |
| |
| return (localName.equals(schemaLocalName) && |
| Constants.isSchemaXSD(node.getNamespaceURI())); |
| } |
| |
| /** |
| * Look for the base type of node iff node is a complex type that has been |
| * derived by restriction; otherwise return null. |
| * |
| * @param node |
| * @param symbolTable |
| * @return |
| */ |
| public static TypeEntry getComplexElementRestrictionBase(Node node, |
| SymbolTable symbolTable) |
| { |
| if (node == null) |
| return null; |
| |
| // If the node kind is an element, dive into it. |
| if (isXSDNode(node, "element")) |
| { |
| NodeList children = node.getChildNodes(); |
| Node complexNode = null; |
| |
| for (int j = 0; (j < children.getLength()) && (complexNode == null); j++) |
| { |
| if (isXSDNode(children.item(j), "complexType")) |
| { |
| complexNode = children.item(j); |
| node = complexNode; |
| } |
| } |
| } |
| |
| // Expecting a schema complexType |
| if (isXSDNode(node, "complexType")) |
| { |
| // Under the complexType there could be should be a complexContent & |
| // restriction elements if this is a derived type. |
| NodeList children = node.getChildNodes(); |
| Node content = null; |
| Node restriction = null; |
| |
| for (int j = 0; (j < children.getLength()) && (content == null); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexContent") || isXSDNode(kid, "simpleContent")) |
| content = kid; |
| } |
| |
| if (content != null) |
| { |
| children = content.getChildNodes(); |
| |
| for (int j = 0; (j < children.getLength()) && (restriction == null); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "restriction")) |
| restriction = kid; |
| } |
| } |
| |
| if (restriction == null) |
| return null; |
| else |
| { |
| // Get the QName of the extension base |
| QName restrictionType = |
| Utils.getTypeQName(restriction, new BooleanHolder(), false); |
| |
| if (restrictionType == null) |
| return null; |
| else |
| { |
| // Return associated Type |
| return symbolTable.getType(restrictionType); |
| } |
| } |
| } |
| else |
| return null; |
| } |
| |
| /** |
| * If the specified node represents a supported JAX-RPC complexType/element |
| * which extends another complexType. The Type of the base is returned. |
| * |
| * @param node |
| * @param symbolTable |
| * @return |
| */ |
| public static TypeEntry getComplexElementExtensionBase(Node node, |
| SymbolTable symbolTable) |
| { |
| if (node == null) |
| return null; |
| |
| TypeEntry cached = (TypeEntry) symbolTable.node2ExtensionBase.get(node); |
| |
| if (cached != null) |
| return cached; // cache hit |
| |
| // If the node kind is an element, dive into it. |
| if (isXSDNode(node, "element")) |
| { |
| NodeList children = node.getChildNodes(); |
| Node complexNode = null; |
| |
| for (int j = 0; (j < children.getLength()) && (complexNode == null); j++) |
| { |
| if (isXSDNode(children.item(j), "complexType")) |
| { |
| complexNode = children.item(j); |
| node = complexNode; |
| } |
| } |
| } |
| |
| // Expecting a schema complexType |
| if (isXSDNode(node, "complexType")) |
| { |
| // Under the complexType there could be should be a complexContent & |
| // extension elements if this is a derived type. |
| NodeList children = node.getChildNodes(); |
| Node content = null; |
| Node extension = null; |
| |
| for (int j = 0; (j < children.getLength()) && (content == null); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexContent") || isXSDNode(kid, "simpleContent")) |
| content = kid; |
| } |
| |
| if (content != null) |
| { |
| children = content.getChildNodes(); |
| |
| for (int j = 0; (j < children.getLength()) && (extension == null); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "extension")) |
| extension = kid; |
| } |
| } |
| |
| if (extension == null) |
| cached = null; |
| else |
| { |
| // Get the QName of the extension base |
| QName extendsType = |
| Utils.getTypeQName(extension, new BooleanHolder(), false); |
| |
| if (extendsType == null) |
| cached = null; |
| else |
| { |
| // Return associated Type |
| cached = symbolTable.getType(extendsType); |
| } |
| } |
| } |
| |
| symbolTable.node2ExtensionBase.put(node, cached); |
| |
| return cached; |
| } |
| |
| /** |
| * If the specified node represents a 'normal' non-enumeration simpleType, |
| * the QName of the simpleType base is returned. |
| * |
| * @param node |
| * @return |
| */ |
| public static QName getSimpleTypeBase(Node node) |
| { |
| |
| QName[] qname = getContainedSimpleTypes(node); |
| |
| if ((qname != null) && (qname.length > 0)) |
| return qname[0]; |
| |
| return null; |
| } |
| |
| /** |
| * Method getContainedSimpleTypes |
| * |
| * @param node |
| * @return |
| */ |
| public static QName[] getContainedSimpleTypes(Node node) |
| { |
| |
| QName[] baseQNames = null; |
| |
| if (node == null) |
| return null; |
| |
| // If the node kind is an element, dive into it. |
| if (isXSDNode(node, "element")) |
| { |
| NodeList children = node.getChildNodes(); |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| if (isXSDNode(children.item(j), "simpleType")) |
| { |
| node = children.item(j); |
| break; |
| } |
| } |
| } |
| |
| // Get the node kind, expecting a schema simpleType |
| if (isXSDNode(node, "simpleType")) |
| { |
| // Under the simpleType there should be a restriction. |
| // (There may be other #text nodes, which we will ignore). |
| NodeList children = node.getChildNodes(); |
| Node restrictionNode = null; |
| Node unionNode = null; |
| |
| for (int j = 0; |
| (j < children.getLength()) && (restrictionNode == null); |
| j++) |
| { |
| if (isXSDNode(children.item(j), "restriction")) |
| restrictionNode = children.item(j); |
| else if (isXSDNode(children.item(j), "union")) |
| unionNode = children.item(j); |
| } |
| |
| // The restriction node indicates the type being restricted |
| // (the base attribute contains this type). |
| if (restrictionNode != null) |
| { |
| baseQNames = new QName[1]; |
| baseQNames[0] = |
| Utils.getTypeQName(restrictionNode, new BooleanHolder(), false); |
| } |
| |
| if (unionNode != null) |
| baseQNames = Utils.getMemberTypeQNames(unionNode); |
| |
| // Look for enumeration elements underneath the restriction node |
| if ((baseQNames != null) && (restrictionNode != null) && (unionNode != null)) |
| { |
| NodeList enums = restrictionNode.getChildNodes(); |
| |
| for (int i = 0; i < enums.getLength(); i++) |
| { |
| if (isXSDNode(enums.item(i), "enumeration")) |
| { |
| // Found an enumeration, this isn't a |
| // 'normal' simple type. |
| return null; |
| } |
| } |
| } |
| } |
| |
| return baseQNames; |
| } |
| |
| /** |
| * Returns the contained restriction or extension node underneath |
| * the specified node. Returns null if not found |
| * |
| * @param node |
| * @return |
| */ |
| public static Node getRestrictionOrExtensionNode(Node node) |
| { |
| |
| Node re = null; |
| |
| if (node == null) |
| return re; |
| |
| // If the node kind is an element, dive into it. |
| if (isXSDNode(node, "element")) |
| { |
| NodeList children = node.getChildNodes(); |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node n = children.item(j); |
| |
| if (isXSDNode(n, "simpleType") || isXSDNode(n, "complexType") |
| || isXSDNode(n, "simpleContent")) |
| { |
| node = n; |
| break; |
| } |
| } |
| } |
| |
| // Get the node kind, expecting a schema simpleType |
| if (isXSDNode(node, "simpleType") || isXSDNode(node, "complexType")) |
| { |
| // Under the complexType there could be a complexContent. |
| NodeList children = node.getChildNodes(); |
| Node complexContent = null; |
| |
| if (node.getLocalName().equals("complexType")) |
| { |
| for (int j = 0; (j < children.getLength()) && (complexContent == null); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexContent") || isXSDNode(kid, "simpleContent")) |
| complexContent = kid; |
| } |
| |
| node = complexContent; |
| } |
| |
| // Now get the extension or restriction node |
| if (node != null) |
| { |
| children = node.getChildNodes(); |
| |
| for (int j = 0;(j < children.getLength()) && (re == null); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "extension") || isXSDNode(kid, "restriction")) |
| re = kid; |
| } |
| } |
| } |
| |
| return re; |
| } |
| |
| /** |
| * If the specified node represents an array encoding of one of the following |
| * forms, then return the qname repesenting the element type of the array. |
| * |
| * @param node is the node |
| * @param dims is the output value that contains the number of dimensions if return is not null |
| * @param itemQName will end up containing the "inner" QName for a |
| * wrapped literal array |
| * @return QName or null |
| */ |
| public static QName getArrayComponentQName(Node node, |
| IntHolder dims, |
| SymbolTable symbolTable) |
| { |
| dims.value = 1; // assume 1 dimension |
| |
| QName qName = getCollectionComponentQName(node); |
| |
| if (qName == null) |
| qName = getArrayComponentQName_JAXRPC(node, dims, symbolTable); |
| |
| return qName; |
| } |
| |
| /** |
| * If the specified node represents an element that references a collection |
| * then return the qname repesenting the component of the collection. |
| * <p/> |
| * <xsd:element name="alias" type="xsd:string" maxOccurs="unbounded"/> |
| * returns qname for"xsd:string" |
| * <p/> |
| * <xsd:complexType> |
| * <xsd:sequence> |
| * <xsd:element name="alias" type="xsd:string" maxOccurs="unbounded"/> |
| * </xsd:sequence> |
| * </xsd:complexType> |
| * returns qname for"xsd:string" |
| * <p/> |
| * <xsd:element ref="alias" maxOccurs="unbounded"/> |
| * returns qname for "alias" |
| * |
| * @param node is the Node |
| * @return QName of the compoent of the collection |
| */ |
| public static QName getCollectionComponentQName(Node node) |
| { |
| if (node == null) |
| return null; |
| |
| // If the node kind is an element, dive get its type. |
| if (isXSDNode(node, "element")) |
| { |
| // Compare the componentQName with the name of the |
| // full name. If different, return componentQName |
| BooleanHolder forElement = new BooleanHolder(); |
| QName componentQName = Utils.getTypeQName(node, forElement, true); |
| |
| if (componentQName != null) |
| { |
| QName fullQName = Utils.getTypeQName(node, forElement, false); |
| |
| if (!componentQName.equals(fullQName)) |
| return componentQName; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * If the specified node represents an array encoding of one of the following |
| * forms, then return the qname repesenting the element type of the array. |
| * |
| * @param node is the node |
| * @param dims is the output value that contains the number of dimensions if return is not null |
| * @return QName or null |
| * <p/> |
| * JAX-RPC Style 2: |
| * <xsd:complexType name="hobbyArray"> |
| * <xsd:complexContent> |
| * <xsd:restriction base="soapenc:Array"> |
| * <xsd:attribute ref="soapenc:arrayType" wsdl:arrayType="xsd:string[]"/> |
| * </xsd:restriction> |
| * </xsd:complexContent> |
| * </xsd:complexType> |
| * <p/> |
| * JAX-RPC Style 3: |
| * <xsd:complexType name="petArray"> |
| * <xsd:complexContent> |
| * <xsd:restriction base="soapenc:Array"> |
| * <xsd:sequence> |
| * <xsd:element name="alias" type="xsd:string" maxOccurs="unbounded"/> |
| * </xsd:sequence> |
| * </xsd:restriction> |
| * </xsd:complexContent> |
| * </xsd:complexType> |
| */ |
| private static QName getArrayComponentQName_JAXRPC(Node node, |
| IntHolder dims, |
| SymbolTable symbolTable) |
| { |
| |
| dims.value = 0; // Assume 0 |
| |
| if (node == null) |
| return null; |
| |
| // If the node kind is an element, dive into it. |
| if (isXSDNode(node, "element")) |
| { |
| NodeList children = node.getChildNodes(); |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexType")) |
| { |
| node = kid; |
| break; |
| } |
| } |
| } |
| |
| // Get the node kind, expecting a schema complexType |
| if (isXSDNode(node, "complexType")) |
| { |
| // Under the complexType there should be a complexContent. |
| // (There may be other #text nodes, which we will ignore). |
| NodeList children = node.getChildNodes(); |
| Node complexContentNode = null; |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexContent") || isXSDNode(kid, "simpleContent")) |
| { |
| complexContentNode = kid; |
| break; |
| } |
| } |
| |
| // Under the complexContent there should be a restriction. |
| // (There may be other #text nodes, which we will ignore). |
| Node restrictionNode = null; |
| |
| if (complexContentNode != null) |
| { |
| children = complexContentNode.getChildNodes(); |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "restriction")) |
| { |
| restrictionNode = kid; |
| break; |
| } |
| } |
| } |
| |
| // The restriction node must have a base of soapenc:Array. |
| QName baseType = null; |
| |
| if (restrictionNode != null) |
| { |
| baseType = Utils.getTypeQName(restrictionNode, new BooleanHolder(), false); |
| |
| if (baseType != null) |
| { |
| if (!baseType.getLocalPart().equals("Array") || |
| !Constants.isSOAP_ENC(baseType.getNamespaceURI())) |
| { |
| if (!symbolTable.arrayTypeQNames.contains(baseType)) |
| baseType = null; // Did not find base=soapenc:Array |
| } |
| } |
| } |
| |
| // Under the restriction there should be an attribute OR a sequence/all group node. |
| // (There may be other #text nodes, which we will ignore). |
| Node groupNode = null; |
| Node attributeNode = null; |
| |
| if (baseType != null) |
| { |
| children = restrictionNode.getChildNodes(); |
| |
| for (int j = 0; (j < children.getLength()) |
| && (groupNode == null) |
| && (attributeNode == null); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "sequence") || isXSDNode(kid, "all")) |
| { |
| groupNode = kid; |
| |
| if (groupNode.getChildNodes().getLength() == 0) |
| { |
| |
| // This covers the rather odd but legal empty sequence. |
| // <complexType name="ArrayOfString"> |
| // <complexContent> |
| // <restriction base="soapenc:Array"> |
| // <sequence/> |
| // <attribute ref="soapenc:arrayType" wsdl:arrayType="string[]"/> |
| // </restriction> |
| // </complexContent> |
| // </complexType> |
| groupNode = null; |
| } |
| } |
| |
| if (isXSDNode(kid, "attribute")) |
| { |
| // If the attribute node does not have ref="soapenc:arrayType" |
| // then keep looking. |
| BooleanHolder isRef = new BooleanHolder(); |
| QName refQName = Utils.getTypeQName(kid, isRef, false); |
| |
| if ((refQName != null) && isRef.value |
| && refQName.getLocalPart().equals("arrayType") |
| && Constants.isSOAP_ENC(refQName.getNamespaceURI())) |
| attributeNode = kid; |
| } |
| } |
| } |
| |
| // If there is an attribute node, look at wsdl:arrayType to get the element type |
| if (attributeNode != null) |
| { |
| String wsdlArrayTypeValue = null; |
| Vector attrs = Utils.getAttributesWithLocalName(attributeNode, "arrayType"); |
| |
| for (int i = 0; |
| (i < attrs.size()) && (wsdlArrayTypeValue == null); |
| i++) |
| { |
| Node attrNode = (Node) attrs.elementAt(i); |
| String attrName = attrNode.getNodeName(); |
| QName attrQName = Utils.getQNameFromPrefixedName(attributeNode, attrName); |
| |
| if (Constants.isWSDL(attrQName.getNamespaceURI())) |
| wsdlArrayTypeValue = attrNode.getNodeValue(); |
| } |
| |
| // The value could have any number of [] or [,] on the end |
| // Strip these off to get the prefixed name. |
| // The convert the prefixed name into a qname. |
| // Count the number of [ and , to get the dim information. |
| if (wsdlArrayTypeValue != null) |
| { |
| int i = wsdlArrayTypeValue.indexOf('['); |
| |
| if (i > 0) |
| { |
| String prefixedName = wsdlArrayTypeValue.substring(0, i); |
| String mangledString = wsdlArrayTypeValue.replace(',', '['); |
| |
| dims.value = 0; |
| |
| int index = mangledString.indexOf('['); |
| |
| while (index > 0) |
| { |
| dims.value++; |
| index = mangledString.indexOf('[', index + 1); |
| } |
| |
| return Utils.getQNameFromPrefixedName(restrictionNode, prefixedName); |
| } |
| } |
| } |
| else if (groupNode != null) |
| { |
| // Get the first element node under the group node. |
| NodeList elements = groupNode.getChildNodes(); |
| Node elementNode = null; |
| |
| for (int i = 0; (i < elements.getLength()) && (elementNode == null); i++) |
| { |
| Node kid = elements.item(i); |
| |
| if (isXSDNode(kid, "element")) |
| { |
| elementNode = elements.item(i); |
| break; |
| } |
| } |
| |
| // The element node should have maxOccurs="unbounded" and |
| // a type |
| if (elementNode != null) |
| { |
| String maxOccursValue = Utils.getAttribute(elementNode, "maxOccurs"); |
| |
| if ((maxOccursValue != null) && maxOccursValue.equalsIgnoreCase("unbounded")) |
| { |
| // Get the QName of the type without considering maxOccurs |
| dims.value = 1; |
| |
| return Utils.getTypeQName(elementNode, new BooleanHolder(), true); |
| } |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * adds an attribute node's type and name to the vector |
| * helper used by getContainedAttributeTypes |
| * |
| * @param v |
| * @param child |
| * @param symbolTable |
| */ |
| private static void addAttributeToVector(Vector v, Node child, |
| SymbolTable symbolTable) |
| { |
| // Get the name and type qnames. |
| // The type qname is used to locate the TypeEntry, which is then |
| // used to retrieve the proper java name of the type. |
| QName attributeName = Utils.getNodeNameQName(child); |
| BooleanHolder forElement = new BooleanHolder(); |
| QName attributeType = Utils.getTypeQName(child, forElement, false); |
| |
| // An attribute is either qualified or unqualified. |
| // If the ref= attribute is used, the name of the ref'd element is used |
| // (which must be a root element). If the ref= attribute is not |
| // used, the name of the attribute is unqualified. |
| if (!forElement.value) |
| { |
| // check the Form (or attributeFormDefault) attribute of |
| // this node to determine if it should be namespace |
| // quailfied or not. |
| String form = Utils.getAttribute(child, "form"); |
| |
| if ((form != null) && form.equals("unqualified")) |
| { |
| // Unqualified nodeName |
| attributeName = Utils.findQName("", attributeName.getLocalPart()); |
| } |
| else if (form == null) |
| { |
| // check attributeFormDefault on schema element |
| String def = Utils.getScopedAttribute(child, "attributeFormDefault"); |
| |
| if ((def == null) || def.equals("unqualified")) |
| attributeName = Utils.findQName("", attributeName.getLocalPart()); |
| } |
| } |
| else |
| attributeName = attributeType; |
| |
| // Get the corresponding TypeEntry from the symbol table |
| TypeEntry type = symbolTable.getTypeEntry(attributeType, forElement.value); |
| |
| // Try to get the corresponding global attribute ElementEntry |
| // from the symbol table. |
| if (type instanceof org.apache.axis.wsdl.symbolTable.Element) |
| type = ((org.apache.axis.wsdl.symbolTable.Element) type).getRefType(); |
| |
| // add type and name to vector, skip it if we couldn't parse it |
| // XXX - this may need to be revisited. |
| if ((type != null) && (attributeName != null)) |
| { |
| CContainedAttribute attr = new CContainedAttribute(type, attributeName); |
| |
| String useValue = Utils.getAttribute(child, "use"); |
| if (useValue != null) |
| attr.setOptional(useValue.equalsIgnoreCase("optional")); |
| |
| String fixedValue = Utils.getAttribute(child, "fixed"); |
| if (fixedValue != null) |
| attr.setFixedValue(fixedValue); |
| |
| String defaultValue = Utils.getAttribute(child, "default"); |
| if (defaultValue != null) |
| attr.setDefaultValue(defaultValue); |
| |
| v.add(attr); |
| } |
| } |
| |
| /** |
| * adds an attribute to the vector |
| * helper used by addAttributeGroupToVector |
| * |
| * @param v |
| * @param symbolTable |
| * @param type |
| * @param name |
| */ |
| private static void addAttributeToVector(Vector v, SymbolTable symbolTable, |
| QName type, QName name) |
| { |
| TypeEntry typeEnt = symbolTable.getTypeEntry(type, false); |
| |
| if (typeEnt != null) |
| v.add(new CContainedAttribute(typeEnt, name)); |
| } |
| |
| /** |
| * adds each attribute group's attribute node to the vector |
| * helper used by getContainedAttributeTypes |
| * |
| * @param v |
| * @param attrGrpnode |
| * @param symbolTable |
| */ |
| private static void addAttributeGroupToVector(Vector v, Node attrGrpnode, |
| SymbolTable symbolTable) |
| { |
| // get the type of the attributeGroup |
| QName attributeGroupType = Utils.getTypeQName(attrGrpnode, new BooleanHolder(), false); |
| TypeEntry type = symbolTable.getTypeEntry(attributeGroupType, false); |
| |
| if (type != null) |
| { |
| if (type.getNode() != null) |
| { |
| // for each attribute or attributeGroup defined in the attributeGroup... |
| NodeList children = type.getNode().getChildNodes(); |
| |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "attribute")) |
| addAttributeToVector(v, kid, symbolTable); |
| else if (isXSDNode(kid, "attributeGroup")) |
| addAttributeGroupToVector(v, kid, symbolTable); |
| } |
| } |
| else if (type.isBaseType()) |
| { |
| // soap/encoding is treated as a "known" schema |
| // so let's act like we know it |
| if (type.getQName().equals(Constants.SOAP_COMMON_ATTRS11)) |
| { |
| // 1.1 commonAttributes contains two attributes |
| addAttributeToVector(v, symbolTable, Constants.XSD_ID, |
| new QName(Constants.URI_SOAP11_ENC, "id")); |
| addAttributeToVector(v, symbolTable, Constants.XSD_ANYURI, |
| new QName(Constants.URI_SOAP11_ENC, "href")); |
| } |
| else if (type.getQName().equals(Constants.SOAP_COMMON_ATTRS12)) |
| { |
| // 1.2 commonAttributes contains one attribute |
| addAttributeToVector(v, symbolTable, Constants.XSD_ID, |
| new QName(Constants.URI_SOAP12_ENC, "id")); |
| } |
| else if (type.getQName().equals(Constants.SOAP_ARRAY_ATTRS11)) |
| { |
| // 1.1 arrayAttributes contains two attributes |
| addAttributeToVector(v, symbolTable, Constants.XSD_STRING, |
| new QName(Constants.URI_SOAP12_ENC, "arrayType")); |
| addAttributeToVector(v, symbolTable, Constants.XSD_STRING, |
| new QName(Constants.URI_SOAP12_ENC, "offset")); |
| } |
| else if (type.getQName().equals(Constants.SOAP_ARRAY_ATTRS12)) |
| { |
| // 1.2 arrayAttributes contains two attributes |
| // the type of "arraySize" is really "2003soapenc:arraySize" |
| // which is rather of a hairy beast that is not yet supported |
| // in Axis, so let's just use string; nobody should care for |
| // now because arraySize wasn't used at all up until this |
| // bug 23145 was fixed, which had nothing to do, per se, with |
| // adding support for arraySize |
| addAttributeToVector(v, symbolTable, Constants.XSD_STRING, |
| new QName(Constants.URI_SOAP12_ENC, "arraySize")); |
| addAttributeToVector(v, symbolTable, Constants.XSD_QNAME, |
| new QName(Constants.URI_SOAP12_ENC, "itemType")); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Return the attribute names and types if any in the node |
| * The even indices are the attribute types (TypeEntry) and |
| * the odd indices are the corresponding names (Strings). |
| * <p/> |
| * Example: |
| * <complexType name="Person"> |
| * <sequence> |
| * <element minOccurs="1" maxOccurs="1" name="Age" type="double" /> |
| * <element minOccurs="1" maxOccurs="1" name="ID" type="xsd:float" /> |
| * </sequence> |
| * <attribute name="Name" type="string" /> |
| * <attribute name="Male" type="boolean" /> |
| * <attributeGroup ref="s0:MyAttrSet" /> |
| * </complexType> |
| * |
| * @param node |
| * @param symbolTable |
| * @return |
| */ |
| public static Vector getContainedAttributeTypes(Node node, |
| SymbolTable symbolTable) |
| { |
| |
| Vector v = null; // return value |
| |
| if (node == null) |
| return null; |
| |
| // Check for SimpleContent |
| // If the node kind is an element, dive into it. |
| if (isXSDNode(node, "element")) |
| { |
| NodeList children = node.getChildNodes(); |
| int len = children.getLength(); |
| for (int j = 0; j < len; j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexType")) |
| { |
| node = kid; |
| break; |
| } |
| } |
| } |
| |
| // Expecting a schema complexType |
| if (isXSDNode(node, "complexType")) |
| { |
| // Under the complexType there could be complexContent/simpleContent |
| // and extension elements if this is a derived type. Skip over these. |
| NodeList children = node.getChildNodes(); |
| Node content = null; |
| int len = children.getLength(); |
| for (int j = 0; j < len; j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "complexContent") || isXSDNode(kid, "simpleContent")) |
| { |
| content = kid; |
| break; |
| } |
| } |
| |
| // Check for extensions or restrictions |
| if (content != null) |
| { |
| children = content.getChildNodes(); |
| len = children.getLength(); |
| for (int j = 0; j < len; j++) |
| { |
| Node kid = children.item(j); |
| |
| if (isXSDNode(kid, "extension") || isXSDNode(kid, "restriction")) |
| { |
| node = kid; |
| break; |
| } |
| } |
| } |
| |
| // examine children of the node for <attribute> elements |
| children = node.getChildNodes(); |
| len = children.getLength(); |
| for (int i = 0; i < len; i++) |
| { |
| Node child = children.item(i); |
| |
| if (isXSDNode(child, "attributeGroup")) |
| { |
| if (v == null) |
| v = new Vector(); |
| |
| addAttributeGroupToVector(v, child, symbolTable); |
| } |
| else if (isXSDNode(child, "anyAttribute")) |
| { |
| // do nothing right now |
| if (v == null) |
| v = new Vector(); |
| } |
| else if (isXSDNode(child, "attribute")) |
| { |
| if (v == null) |
| v = new Vector(); |
| |
| addAttributeToVector(v, child, symbolTable); |
| } |
| } |
| } |
| |
| return v; |
| } |
| |
| // list of all of the XSD types in Schema 2001 |
| |
| /** Field schemaTypes[] */ |
| private static String schemaTypes[] = { |
| "string", "normalizedString", "token", "byte", "unsignedByte", |
| "base64Binary", "hexBinary", "integer", "positiveInteger", |
| "negativeInteger", "nonNegativeInteger", "nonPositiveInteger", "int", |
| "unsignedInt", "long", "unsignedLong", "short", "unsignedShort", |
| "decimal", "float", "double", "boolean", "time", "dateTime", "duration", |
| "date", "gMonth", "gYear", "gYearMonth", "gDay", "gMonthDay", "Name", |
| "QName", "NCName", "anyURI", "language", "ID", "IDREF", "IDREFS", |
| "ENTITY", "ENTITIES", "NOTATION", "NMTOKEN", "NMTOKENS", |
| "anySimpleType" |
| }; |
| |
| /** Field schemaTypeSet */ |
| private static final Set schemaTypeSet = new HashSet(Arrays.asList(schemaTypes)); |
| |
| /** |
| * Determine if a string is a simple XML Schema type |
| * |
| * @param s |
| * @return |
| */ |
| private static boolean isSimpleSchemaType(String s) { |
| if (s == null) |
| return false; |
| |
| return schemaTypeSet.contains(s); |
| } |
| |
| /** |
| * Determine if a QName is a simple XML Schema type |
| * |
| * @param qname |
| * @return |
| */ |
| public static boolean isSimpleSchemaType(QName qname) |
| { |
| |
| if ((qname == null) || !Constants.isSchemaXSD(qname.getNamespaceURI())) |
| return false; |
| |
| return isSimpleSchemaType(qname.getLocalPart()); |
| } |
| |
| /** |
| * Returns the base type of a given type with its symbol table. |
| * This logic is extracted from JavaTypeWriter's constructor() method |
| * for reusing. |
| * |
| * @param type |
| * @param symbolTable |
| * @return |
| */ |
| public static TypeEntry getBaseType(TypeEntry type, SymbolTable symbolTable) { |
| Node node = type.getNode(); |
| TypeEntry base = getComplexElementExtensionBase(node, symbolTable); |
| if (base == null) |
| base = getComplexElementRestrictionBase(node, symbolTable); |
| |
| if (base == null) |
| { |
| QName baseQName = getSimpleTypeBase(node); |
| if (baseQName != null) |
| base = symbolTable.getType(baseQName); |
| } |
| return base; |
| } |
| |
| /** |
| * Returns whether the specified node represents a <xsd:simpleType> |
| * with a nested <xsd:list itemType="...">. |
| * @param node |
| * @return |
| */ |
| public static boolean isListWithItemType(Node node) |
| { |
| return getListItemType(node) != null; |
| } |
| |
| /** |
| * Returns the value of itemType attribute of <xsd:list> in <xsd:simpleType> |
| * @param node |
| * @return |
| */ |
| public static QName getListItemType(Node node) |
| { |
| |
| if (node == null) |
| return null; |
| |
| // If the node kind is an element, dive into it. |
| if (isXSDNode(node, "element")) |
| { |
| NodeList children = node.getChildNodes(); |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| if (isXSDNode(children.item(j), "simpleType")) |
| { |
| node = children.item(j); |
| break; |
| } |
| } |
| } |
| |
| // Get the node kind, expecting a schema simpleType |
| if (isXSDNode(node, "simpleType")) |
| { |
| NodeList children = node.getChildNodes(); |
| for (int j = 0; j < children.getLength(); j++) |
| { |
| if (isXSDNode(children.item(j), "list")) |
| { |
| Node listNode = children.item(j); |
| org.w3c.dom.Element listElement = (org.w3c.dom.Element) listNode; |
| String type = listElement.getAttribute("itemType"); |
| if (type.equals("")) |
| { |
| Node localType = null; |
| children = listNode.getChildNodes(); |
| for (j = 0; j < children.getLength() && localType == null; j++) |
| { |
| if (isXSDNode(children.item(j), "simpleType")) |
| localType = children.item(j); |
| } |
| |
| if (localType != null) |
| return getSimpleTypeBase(localType); |
| |
| return null; |
| } |
| //int colonIndex = type.lastIndexOf(":"); |
| //if (colonIndex > 0) { |
| //type = type.substring(colonIndex + 1); |
| //} |
| //return new QName(Constants.URI_2001_SCHEMA_XSD, type + "[]"); |
| return Utils.getQNameFromPrefixedName(node, type); |
| } |
| } |
| } |
| return null; |
| } |
| |
| /* |
| * check whether node should be namespace qualified or not by checking for "form" |
| * attribute. If "form" attribute not specified, the defaultAnswer is returned. |
| */ |
| public static boolean shouldWeNamespaceQualifyNode(Node elementNode, boolean defaultAnswer) |
| { |
| if (null == elementNode || elementNode.getNodeType() != Node.ELEMENT_NODE) |
| return defaultAnswer; |
| |
| // Ensure node represents an "element" node. If not, get the parent. |
| if (!elementNode.getLocalName().equals("element")) |
| return shouldWeNamespaceQualifyNode(elementNode.getParentNode(), defaultAnswer); |
| |
| String form = Utils.getAttribute(elementNode, "form"); |
| if (form != null) |
| { |
| if (form.equals("qualified")) |
| return true; |
| else |
| return false; |
| } |
| else |
| return defaultAnswer; |
| } |
| |
| /* |
| * Find out whether schema's elementFormDefault is "qualified" or not. This is done by |
| * recursively interrogating parent nodes until it is found or not. |
| */ |
| public static boolean isElementFormDefaultQualified(Node elementNode) |
| { |
| if (elementNode != null) |
| { |
| String def = Utils.getScopedAttribute(elementNode, "elementFormDefault"); |
| if ((def != null) && def.equals("qualified")) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /* |
| * Find out whether schema's attributeFormDefault is "qualified" or not. This is done by |
| * recursively interrogating parent nodes until it is found or not. |
| */ |
| public static boolean isAttributeFormDefaultQualified(Node attributeNode) |
| { |
| if (attributeNode != null) |
| { |
| String def = Utils.getScopedAttribute(attributeNode, "attributeFormDefault"); |
| if ((def != null) && def.equals("qualified")) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| } |
