SchemaUtilspublic class SchemaUtils extends Object | This class contains static utility methods specifically for schema type queries. |
| Fields Summary |
|---|
| static final QName | VALUE_QNAMEField VALUE_QNAME | | private static String[] | schemaTypesField schemaTypes[] | | private static final Set | schemaTypeSetField schemaTypeSet |
| Methods Summary |
|---|
| private static void | addAttributeGroupToVector(java.util.Vector v, org.w3c.dom.Node attrGrpnode, SymbolTable symbolTable)adds each attribute group's attribute node to the vector
helper used by getContainedAttributeTypes
// 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"));
}
}
}
| | private static void | addAttributeToVector(java.util.Vector v, org.w3c.dom.Node child, SymbolTable symbolTable)adds an attribute node's type and name to the vector
helper used by getContainedAttributeTypes
// 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")) {
// Unqualified nodeName
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)) {
ContainedAttribute attr =
new ContainedAttribute(type, attributeName);
String useValue = Utils.getAttribute(child, "use");
if (useValue != null) {
attr.setOptional(useValue.equalsIgnoreCase("optional"));
}
v.add(attr);
}
| | private static void | addAttributeToVector(java.util.Vector v, SymbolTable symbolTable, javax.xml.namespace.QName type, javax.xml.namespace.QName name)adds an attribute to the vector
helper used by addAttributeGroupToVector
TypeEntry typeEnt = symbolTable.getTypeEntry(type, false);
if (typeEnt != null) // better not be null
{
v.add(new ContainedAttribute(typeEnt, name));
}
| | public static java.lang.String | getAnnotationDocumentation(org.w3c.dom.Node typeNode)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.
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;
| | public static javax.xml.namespace.QName | getArrayComponentQName(org.w3c.dom.Node node, javax.xml.rpc.holders.IntHolder dims, javax.xml.rpc.holders.BooleanHolder underlTypeNillable, javax.xml.rpc.holders.QNameHolder itemQName, javax.xml.rpc.holders.BooleanHolder forElement, SymbolTable symbolTable)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.
dims.value = 1; // assume 1 dimension
underlTypeNillable.value = false; // assume underlying type is not nillable
QName qName = getCollectionComponentQName(node, itemQName, forElement, symbolTable);
if (qName == null) {
qName = getArrayComponentQName_JAXRPC(node, dims, underlTypeNillable, symbolTable);
}
return qName;
| | private static javax.xml.namespace.QName | getArrayComponentQName_JAXRPC(org.w3c.dom.Node node, javax.xml.rpc.holders.IntHolder dims, javax.xml.rpc.holders.BooleanHolder underlTypeNillable, SymbolTable symbolTable)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.
dims.value = 0; // Assume 0
underlTypeNillable.value = false;
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 underlTypeNillableValue = Utils.getAttribute(elementNode,
"nillable");
if (underlTypeNillableValue != null
&& underlTypeNillableValue.equals("true")) {
underlTypeNillable.value = true;
}
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;
| | public static javax.xml.namespace.QName | getAttributeAnonQName(org.w3c.dom.Node node)Returns the WSDL2Java QName for the anonymous type of the attribute
or null.
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;
| | public static TypeEntry | getBaseType(TypeEntry type, SymbolTable symbolTable)Returns the base type of a given type with its symbol table.
This logic is extracted from JavaTypeWriter's constructor() method
for reusing.
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;
| | private static org.w3c.dom.Node | getChildByName(org.w3c.dom.Node parentNode, java.lang.String name)Returns named child node.
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;
| | public static javax.xml.namespace.QName | getCollectionComponentQName(org.w3c.dom.Node node, javax.xml.rpc.holders.QNameHolder itemQName, javax.xml.rpc.holders.BooleanHolder forElement, SymbolTable symbolTable)If the specified node represents an element that references a collection
then return the qname repesenting the component of the collection.
returns qname for"xsd:string"
returns qname for"xsd:string"
returns qname for "alias"
// If we're going to turn "wrapped" arrays into types such that
// <complexType><sequence>
// <element name="foo" type="xs:string" maxOccurs="unbounded"/>
// </sequence></complexType>
// becomes just "String []", we need to keep track of the inner
// element name "foo" in metadata... This flag indicates whether to
// do so.
boolean storeComponentQName = false;
if (node == null) {
return null;
}
if (itemQName != null && isXSDNode(node, "complexType")) {
// If this complexType is a sequence of exactly one element
// we will continue processing below using that element, and
// let the type checking logic determine if this is an array
// or not.
Node sequence = SchemaUtils.getChildByName(node, "sequence");
if (sequence == null) {
return null;
}
NodeList children = sequence.getChildNodes();
Node element = null;
for (int i = 0; i < children.getLength(); i++) {
if (children.item(i).getNodeType() == Node.ELEMENT_NODE) {
if (element == null) {
element = children.item(i);
} else {
return null;
}
}
}
if (element == null) {
return null;
}
// OK, exactly one element child of <sequence>,
// continue the processing using that element ...
node = element;
storeComponentQName = true;
try {
symbolTable.createTypeFromRef(node);
} catch (IOException e) {
throw new RuntimeException(Messages.getMessage("exception01",e.toString()));
}
}
// If the node kind is an element, dive to get its type.
if (isXSDNode(node, "element")) {
// Compare the componentQName with the name of the
// full name. If different, return componentQName
QName componentTypeQName = Utils.getTypeQName(node,
forElement,
true);
if (componentTypeQName != null) {
QName fullQName = Utils.getTypeQName(node, forElement, false);
if (!componentTypeQName.equals(fullQName)) {
if (storeComponentQName) {
String name = Utils.getAttribute(node, "name");
if (name != null) {
// check elementFormDefault on schema element
String def = Utils.getScopedAttribute(node,
"elementFormDefault");
String namespace = "";
if ((def != null) && def.equals("qualified")) {
namespace = Utils.getScopedAttribute(node, "targetNamespace");
}
itemQName.value = new QName(namespace, name);
}
}
return componentTypeQName;
}
}
}
return null;
| | public static TypeEntry | getComplexElementExtensionBase(org.w3c.dom.Node node, SymbolTable symbolTable)If the specified node represents a supported JAX-RPC complexType/element
which extends another complexType. The Type of the base is returned.
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;
| | public static TypeEntry | getComplexElementRestrictionBase(org.w3c.dom.Node node, SymbolTable symbolTable)Look for the base type of node iff node is a complex type that has been
derived by restriction; otherwise return null.
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;
}
| | public static java.util.Vector | getContainedAttributeTypes(org.w3c.dom.Node node, SymbolTable symbolTable)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).
Example:
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")) {
// we have an attribute
if (v == null) {
v = new Vector();
}
addAttributeToVector(v, child, symbolTable);
}
}
}
return v;
| | public static java.util.Vector | getContainedElementDeclarations(org.w3c.dom.Node node, SymbolTable symbolTable)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.
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();
ElementDecl elem =
new ElementDecl(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++) {
Type 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 ElementDecl(simpleType, qname));
}
}
return v;
}
}
return null;
| | public static javax.xml.namespace.QName[] | getContainedSimpleTypes(org.w3c.dom.Node node)Method getContainedSimpleTypes
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;
| | public static javax.xml.namespace.QName | getElementAnonQName(org.w3c.dom.Node node)Returns the WSDL2Java QName for the anonymous type of the element
or null.
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;
| | public static javax.xml.namespace.QName | getListItemType(org.w3c.dom.Node node)Returns the value of itemType attribute of in
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;
| | public static org.w3c.dom.Node | getListNode(org.w3c.dom.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 org.w3c.dom.Node | getRestrictionOrExtensionNode(org.w3c.dom.Node node)Returns the contained restriction or extension node underneath
the specified node. Returns null if not found
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;
| | public static javax.xml.namespace.QName | getSimpleTypeBase(org.w3c.dom.Node node)If the specified node represents a 'normal' non-enumeration simpleType,
the QName of the simpleType base is returned.
QName[] qname = getContainedSimpleTypes(node);
if ((qname != null) && (qname.length > 0)) {
return qname[0];
}
return null;
| | public static java.lang.String | getTextByPath(org.w3c.dom.Node root, java.lang.String path)Returns all textual nodes of a subnode defined by a parent node
and a path of element names to that subnode.
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;
| | public static org.w3c.dom.Node | getUnionNode(org.w3c.dom.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 boolean | isListWithItemType(org.w3c.dom.Node node)Returns whether the specified node represents a
with a nested .
return getListItemType(node) != null;
| | public static boolean | isMixed(org.w3c.dom.Node node)This method checks mixed=true attribute is set either on
complexType or complexContent element.
// 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;
| | private static boolean | isSimpleSchemaType(java.lang.String s)Determine if a string is a simple XML Schema type
if (s == null) {
return false;
}
return schemaTypeSet.contains(s);
| | public static boolean | isSimpleSchemaType(javax.xml.namespace.QName qname)Determine if a QName is a simple XML Schema type
if ((qname == null) || !Constants.isSchemaXSD(qname.getNamespaceURI())) {
return false;
}
return isSimpleSchemaType(qname.getLocalPart());
| | public static boolean | isSimpleTypeOrSimpleContent(org.w3c.dom.Node node)If the specified node is a simple type or contains simpleContent, return true
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;
| | public static boolean | isSimpleTypeWithUnion(org.w3c.dom.Node node)
return (getUnionNode(node) != null);
| | public static boolean | isWrappedType(org.w3c.dom.Node node)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.)
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;
| | private static boolean | isXSDNode(org.w3c.dom.Node node, java.lang.String schemaLocalName)Test whether node is not null, belongs to the XML
Schema namespace, and has a localName that matches
schemaLocalName
This can be used to determine that a given Node defines a
schema "complexType" "element" and so forth.
if (node == null) {
return false;
}
String localName = node.getLocalName();
if (localName == null) {
return false;
}
return (localName.equals(schemaLocalName) &&
Constants.isSchemaXSD(node.getNamespaceURI()));
| | private static java.util.Vector | processAllNode(org.w3c.dom.Node allNode, SymbolTable symbolTable)Invoked by getContainedElementDeclarations to get the child element types
and child element names underneath an all node.
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")) {
ElementDecl elem = processChildElementNode(kid, symbolTable);
if (elem != null) {
v.add(elem);
}
}
}
return v;
| | private static ElementDecl | processChildElementNode(org.w3c.dom.Node elementNode, SymbolTable symbolTable)Invoked by getContainedElementDeclarations to get the child element type
and child element name for a child element node.
If the specified node represents a supported JAX-RPC child element,
we return an ElementDecl containing the child element name and type.
// 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);
// 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")) {
// Unqualified nodeName
nodeName = Utils.findQName("", nodeName.getLocalPart());
} else if (form == null) {
// check elementFormDefault on schema element
String def = Utils.getScopedAttribute(elementNode,
"elementFormDefault");
if ((def == null) || def.equals("unqualified")) {
// Unqualified nodeName
nodeName = Utils.findQName("", nodeName.getLocalPart());
}
}
}
if (type != null) {
ElementDecl elem = new ElementDecl(type, nodeName);
elem.setDocumentation(comments);
String minOccurs = Utils.getAttribute(elementNode,
"minOccurs");
if ((minOccurs != null) && minOccurs.equals("0")) {
elem.setMinOccursIs0(true);
}
String maxOccurs = Utils.getAttribute(elementNode, "maxOccurs");
if (maxOccurs != null) {
if (maxOccurs.equals("unbounded")) {
elem.setMaxOccursIsUnbounded(true);
}
else if(maxOccurs.equals("1")) {
elem.setMaxOccursIsExactlyOne(true);
}
}
else {
elem.setMaxOccursIsExactlyOne(true);
}
elem.setNillable(
JavaUtils.isTrueExplicitly(
Utils.getAttribute(elementNode, "nillable")));
String useValue = Utils.getAttribute(elementNode, "use");
if (useValue != null) {
elem.setOptional(useValue.equalsIgnoreCase("optional"));
}
return elem;
}
return null;
| | private static java.util.Vector | processChoiceNode(org.w3c.dom.Node choiceNode, SymbolTable symbolTable)Invoked by getContainedElementDeclarations to get the child element types
and child element names underneath a Choice Node
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")) {
ElementDecl elem = processChildElementNode(kid,
symbolTable);
if (elem != null) {
// XXX: forces minOccurs="0" so that a null choice
// element can be serialized ok.
elem.setMinOccursIs0(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.
Type type = symbolTable.getType(Constants.XSD_ANY);
ElementDecl elem = new ElementDecl(type,
Utils.findQName("",
"any"));
elem.setAnyElement(true);
v.add(elem);
}
}
}
return v;
| | private static java.util.Vector | processGroupNode(org.w3c.dom.Node groupNode, SymbolTable symbolTable)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.
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 nodeName = Utils.getNodeNameQName(groupNode);
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'.
Type type = (Type) symbolTable.getTypeEntry(nodeType, false);
if (type != null && type.getNode() != null) {
//v.add(new ElementDecl(type, nodeName));
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;
| | private static java.util.Vector | processSequenceNode(org.w3c.dom.Node sequenceNode, SymbolTable symbolTable)Invoked by getContainedElementDeclarations to get the child element types
and child element names underneath a Sequence Node
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.
Type type = symbolTable.getType(Constants.XSD_ANY);
ElementDecl elem = new ElementDecl(type,
Utils.findQName("",
"any"));
elem.setAnyElement(true);
v.add(elem);
} else if (localName.equals("element")) {
ElementDecl elem = processChildElementNode(kid,
symbolTable);
if (elem != null) {
v.add(elem);
}
}
}
}
return v;
|
|
