/*
* Copyright 2004,2005 The Apache Software Foundation.
* Portions Copyright 2006 International Business Machines Corp.
*
* 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.ws.commons.schema;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.Vector;
import javax.xml.namespace.NamespaceContext;
import javax.xml.namespace.QName;
import javax.xml.parsers.DocumentBuilderFactory;
import org.apache.ws.commons.schema.XmlSchemaCollection.SchemaKey;
import org.apache.ws.commons.schema.constants.Constants;
import org.apache.ws.commons.schema.utils.NodeNamespaceContext;
import org.apache.ws.commons.schema.utils.TargetNamespaceValidator;
import org.apache.ws.commons.schema.utils.XDOMUtil;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
public class SchemaBuilder {
Document doc;
XmlSchema schema;
XmlSchemaCollection collection;
private final TargetNamespaceValidator validator;
DocumentBuilderFactory docFac;
/**
* Schema builder constructor
* @param collection
*/
SchemaBuilder(XmlSchemaCollection collection, TargetNamespaceValidator validator) {
this.collection = collection;
this.validator = validator;
schema = new XmlSchema(collection);
}
/**
* build method taking in a document and a validation handler
* @param doc
* @param uri
* @param veh
*/
XmlSchema build(Document doc, String uri, ValidationEventHandler veh) {
Element schemaEl = doc.getDocumentElement();
return handleXmlSchemaElement(schemaEl, uri);
}
/**
* handles the schema element
* @param schemaEl
* @param uri
*/
XmlSchema handleXmlSchemaElement(Element schemaEl, String uri) {
// get all the attributes along with the namespace declns
schema.setNamespaceContext(new NodeNamespaceContext(schemaEl));
setNamespaceAttributes(schema, schemaEl);
XmlSchemaCollection.SchemaKey schemaKey = new XmlSchemaCollection.SchemaKey(schema.logicalTargetNamespace, uri);
if (!collection.containsSchema(schemaKey)) {
collection.addSchema(schemaKey, schema);
}
schema.setElementFormDefault(this.getFormDefault(schemaEl,
"elementFormDefault"));
schema.setAttributeFormDefault(this.getFormDefault(schemaEl,
"attributeFormDefault"));
schema.setBlockDefault(this.getDerivation(schemaEl, "blockDefault"));
schema.setFinalDefault(this.getDerivation(schemaEl, "finalDefault"));
schema.setSourceURI(uri);
//add the extesibility components
processExtensibilityComponents(schema,schemaEl);
/***********
* for ( each childElement)
* if( simpleTypeElement)
* handleSimpleType
* else if( complexType)
* handleComplexType
* else if( element)
* handleElement
* else if( include)
* handleInclude
* else if( import)
* handleImport
* else if (group)
* handleGroup
* else if (attributeGroup)
* handleattributeGroup
* else if( attribute)
* handleattribute
* else if (redefine)
* handleRedefine
* else if(notation)
* handleNotation
* else if (annotation)
* handleAnnotation
*/
Element el = XDOMUtil.getFirstChildElementNS(schemaEl, XmlSchema.SCHEMA_NS);
if (el == null && XDOMUtil.getFirstChildElementNS(schemaEl, "http://www.w3.org/1999/XMLSchema") != null) {
throw new XmlSchemaException("Schema defined using \"http://www.w3.org/1999/XMLSchema\" is not supported. " +
"Please update the schema to the \"" + XmlSchema.SCHEMA_NS + "\" namespace");
}
for (; el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
// String elPrefix = el.getPrefix() == null ? "" : el.getPrefix();
//if(elPrefix.equals(schema.schema_ns_prefix)) {
if (el.getLocalName().equals("simpleType")) {
XmlSchemaType type = handleSimpleType(schema, el, schemaEl);
schema.addType(type);
schema.items.add(type);
collection.resolveType(type.getQName(), type);
} else if (el.getLocalName().equals("complexType")) {
XmlSchemaType type = handleComplexType(schema, el, schemaEl);
schema.addType(type);
schema.items.add(type);
collection.resolveType(type.getQName(), type);
} else if (el.getLocalName().equals("element")) {
XmlSchemaElement element = handleElement(schema, el, schemaEl, true);
if (element.qualifiedName != null)
schema.elements.collection.put(element.qualifiedName, element);
else if (element.refName != null)
schema.elements.collection.put(element.refName, element);
schema.items.add(element);
} else if (el.getLocalName().equals("include")) {
XmlSchemaInclude include = handleInclude(schema,
el, schemaEl);
schema.includes.add(include);
schema.items.add(include);
} else if (el.getLocalName().equals("import")) {
XmlSchemaImport schemaImport = handleImport(schema,
el, schemaEl);
schema.includes.add(schemaImport);
schema.items.add(schemaImport);
} else if (el.getLocalName().equals("group")) {
XmlSchemaGroup group = handleGroup(schema, el, schemaEl);
schema.groups.collection.put(group.name, group);
schema.items.add(group);
} else if (el.getLocalName().equals("attributeGroup")) {
XmlSchemaAttributeGroup group = handleAttributeGroup(schema,
el, schemaEl);
schema.attributeGroups.collection.put(group.name, group);
schema.items.add(group);
} else if (el.getLocalName().equals("attribute")) {
XmlSchemaAttribute attr = handleAttribute(schema,
el, schemaEl);
schema.attributes.collection.put(attr.qualifiedName, attr);
schema.items.add(attr);
} else if (el.getLocalName().equals("redefine")) {
XmlSchemaRedefine redefine = handleRedefine(schema,
el, schemaEl);
schema.includes.add(redefine);
} else if (el.getLocalName().equals("notation")) {
XmlSchemaNotation notation = handleNotation(el);
schema.notations.collection.put(notation.name, notation);
schema.items.add(notation);
} else if (el.getLocalName().equals("annotation")) {
XmlSchemaAnnotation annotation = handleAnnotation(el);
schema.setAnnotation(annotation);
}
}
return schema;
}
private XmlSchemaNotation handleNotation(
Element notationEl
) {
XmlSchemaNotation notation = new XmlSchemaNotation();
if (notationEl.hasAttribute("id")) {
notation.id = notationEl.getAttribute("id");
}
if (notationEl.hasAttribute("name")) {
notation.name = notationEl.getAttribute("name");
}
if (notationEl.hasAttribute("public")) {
notation.publicNotation = notationEl.getAttribute("public");
}
if (notationEl.hasAttribute("system")) {
notation.system = notationEl.getAttribute("system");
}
Element annotationEl =
XDOMUtil.getFirstChildElementNS(notationEl,
XmlSchema.SCHEMA_NS, "annotation");
if (annotationEl != null) {
XmlSchemaAnnotation annotation = handleAnnotation(annotationEl);
notation.setAnnotation(annotation);
}
return notation;
}
private XmlSchemaRedefine handleRedefine(XmlSchema schema,
Element redefineEl, Element schemaEl) {
XmlSchemaRedefine redefine = new XmlSchemaRedefine();
redefine.schemaLocation =
redefineEl.getAttribute("schemaLocation");
final TargetNamespaceValidator validator = newIncludeValidator(schema);
redefine.schema =
resolveXmlSchema(schema.logicalTargetNamespace, redefine.schemaLocation, validator);
for (Element el = XDOMUtil.getFirstChildElementNS(redefineEl,
XmlSchema.SCHEMA_NS)
; el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
if (el.getLocalName().equals("simpleType")) {
XmlSchemaType type =
handleSimpleType(schema, el, schemaEl);
redefine.schemaTypes.collection.put(type.getQName(),
type);
redefine.items.add(type);
} else if (el.getLocalName().equals("complexType")) {
XmlSchemaType type = handleComplexType(schema, el,
schemaEl);
redefine.schemaTypes.collection.put(type.getQName(),
type);
redefine.items.add(type);
} else if (el.getLocalName().equals("group")) {
XmlSchemaGroup group = handleGroup(schema, el,
schemaEl);
redefine.groups.collection.put(group.name, group);
redefine.items.add(group);
} else if (el.getLocalName().equals("attributeGroup")) {
XmlSchemaAttributeGroup group =
handleAttributeGroup(schema, el, schemaEl);
redefine.attributeGroups.collection.put(group.name, group);
redefine.items.add(group);
} else if (el.getLocalName().equals("annotation")) {
XmlSchemaAnnotation annotation = handleAnnotation(el);
redefine.setAnnotation(annotation);
}
// }
}
return redefine;
}
void setNamespaceAttributes(XmlSchema schema, Element schemaEl) {
//no targetnamespace found !
if (schemaEl.getAttributeNode("targetNamespace") != null) {
String contain = schemaEl.getAttribute("targetNamespace");
schema.setTargetNamespace(contain);
} else {
//do nothing here
}
if (validator != null) {
validator.validate(schema);
}
}
/**
* Handles simple types
* @param schema
* @param simpleEl
* @param schemaEl
*/
XmlSchemaSimpleType handleSimpleType(XmlSchema schema,
Element simpleEl, Element schemaEl) {
XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType(schema);
if (simpleEl.hasAttribute("name")) {
simpleType.name = simpleEl.getAttribute("name");
}
if (simpleEl.hasAttribute("final")) {
String finalstr = simpleEl.getAttribute("final");
if (finalstr.equalsIgnoreCase("all") |
finalstr.equalsIgnoreCase("#all"))
simpleType.setFinal(new XmlSchemaDerivationMethod(Constants.BlockConstants.ALL));
else
simpleType.setFinal(new XmlSchemaDerivationMethod(finalstr));
}
Element simpleTypeAnnotationEl =
XDOMUtil.getFirstChildElementNS(simpleEl,
XmlSchema.SCHEMA_NS, "annotation");
if (simpleTypeAnnotationEl != null) {
XmlSchemaAnnotation simpleTypeAnnotation =
handleAnnotation(simpleTypeAnnotationEl);
simpleType.setAnnotation(simpleTypeAnnotation);
}
Element unionEl, listEl, restrictionEl;
if ((restrictionEl =
XDOMUtil.getFirstChildElementNS(simpleEl, XmlSchema.SCHEMA_NS, "restriction")) != null) {
XmlSchemaSimpleTypeRestriction restriction =
new XmlSchemaSimpleTypeRestriction();
Element restAnnotationEl =
XDOMUtil.getFirstChildElementNS(restrictionEl,
XmlSchema.SCHEMA_NS, "annotation");
if (restAnnotationEl != null) {
XmlSchemaAnnotation restAnnotation =
handleAnnotation(restAnnotationEl);
restriction.setAnnotation(restAnnotation);
}
/** if (restriction has a base attribute )
* set the baseTypeName and look up the base type
* else if( restricion has a SimpleType Element as child)
* get that element and do a handleSimpleType;
* get the children of restriction other than annotation
* and simpleTypes and construct facets from it;
*
* set the restriction has the content of the simpleType
*
**/
Element inlineSimpleType =
XDOMUtil.getFirstChildElementNS(restrictionEl,
XmlSchema.SCHEMA_NS, "simpleType");
if (restrictionEl.hasAttribute("base")) {
NamespaceContext ctx = new NodeNamespaceContext(restrictionEl);
restriction.baseTypeName = getRefQName(restrictionEl.getAttribute("base"), ctx);
} else if (inlineSimpleType != null) {
restriction.baseType = handleSimpleType(schema, inlineSimpleType, schemaEl);
}
for (Element el = XDOMUtil.getFirstChildElementNS(restrictionEl, XmlSchema.SCHEMA_NS)
; el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
if (!el.getLocalName().equals("annotation")
&&
!el.getLocalName().equals("simpleType")) {
XmlSchemaFacet facet = XmlSchemaFacet.construct(el);
Element annotation =
XDOMUtil.getFirstChildElementNS(el, XmlSchema.SCHEMA_NS,
"annotation");
if (annotation != null) {
XmlSchemaAnnotation facetAnnotation =
handleAnnotation(annotation);
facet.setAnnotation(facetAnnotation);
}
restriction.facets.add(facet);
}
}
simpleType.content = restriction;
} else if ((listEl = XDOMUtil.getFirstChildElementNS(simpleEl,
XmlSchema.SCHEMA_NS, "list")) != null) {
XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList();
/******
* if( list has an itemType attribute )
* set the baseTypeName and look up the base type
* else if( list has a SimpleTypeElement as child)
* get that element and do a handleSimpleType
*
* set the list has the content of the simpleType
*/
Element inlineListType, listAnnotationEl;
if (listEl.hasAttribute("itemType")) {
String name = listEl.getAttribute("itemType");
list.itemTypeName = getRefQName(name, listEl);
} else if ((inlineListType =
XDOMUtil.getFirstChildElementNS(listEl, XmlSchema.SCHEMA_NS,
"simpleType")) != null) {
list.itemType = handleSimpleType(schema, inlineListType, schemaEl);
}
if ((listAnnotationEl =
XDOMUtil.getFirstChildElementNS(listEl, XmlSchema.SCHEMA_NS,
"annotation")) != null) {
XmlSchemaAnnotation listAnnotation =
handleAnnotation(listAnnotationEl);
list.setAnnotation(listAnnotation);
}
simpleType.content = list;
} else if ((unionEl =
XDOMUtil.getFirstChildElementNS(simpleEl, XmlSchema.SCHEMA_NS,
"union")) != null) {
XmlSchemaSimpleTypeUnion union =
new XmlSchemaSimpleTypeUnion();
/******
* if( union has a memberTypes attribute )
* add the memberTypeSources string
* for (each memberType in the list )
* lookup(memberType)
* for( all SimpleType child Elements)
* add the simpleTypeName (if any) to the memberType Sources
* do a handleSimpleType with the simpleTypeElement
*/
if (unionEl.hasAttribute("memberTypes")) {
String memberTypes = unionEl.getAttribute("memberTypes");
union.memberTypesSource = memberTypes;
Vector v = new Vector();
StringTokenizer tokenizer = new StringTokenizer(memberTypes, " ");
while (tokenizer.hasMoreTokens()) {
String member = tokenizer.nextToken();
v.add(getRefQName(member, unionEl));
}
union.memberTypesQNames = new QName[v.size()];
v.copyInto(union.memberTypesQNames);
}
Element inlineUnionType =
XDOMUtil.getFirstChildElementNS(unionEl, XmlSchema.SCHEMA_NS,
"simpleType");
while (inlineUnionType != null) {
XmlSchemaSimpleType unionSimpleType =
handleSimpleType(schema, inlineUnionType,
schemaEl);
union.baseTypes.add(unionSimpleType);
if(unionSimpleType.name != null) {
union.memberTypesSource += " " + unionSimpleType.name;
}
inlineUnionType =
XDOMUtil.getNextSiblingElementNS(inlineUnionType,
XmlSchema.SCHEMA_NS,
"simpleType");
}
//NodeList annotations = unionEl.getElementsByTagNameNS(
//XmlSchema.SCHEMA_NS, "annotation");
Element unionAnnotationEl =
XDOMUtil.getFirstChildElementNS(unionEl, XmlSchema.SCHEMA_NS,
"annotation");
if (unionAnnotationEl != null) {
XmlSchemaAnnotation unionAnnotation =
handleAnnotation(unionAnnotationEl);
union.setAnnotation(unionAnnotation);
}
simpleType.content = union;
}
//process extra attributes and elements
processExtensibilityComponents(simpleType,simpleEl);
return simpleType;
}
private QName getRefQName(String pName, Node pNode) {
return getRefQName(pName, new NodeNamespaceContext(pNode));
}
private QName getRefQName(String pName, NamespaceContext pContext) {
final int offset = pName.indexOf(':');
String uri;
final String localName;
final String prefix;
if (offset == -1) {
uri = pContext.getNamespaceURI(Constants.DEFAULT_NS_PREFIX);
if (Constants.NULL_NS_URI.equals(uri)) {
return new QName(schema.logicalTargetNamespace, pName);
}
localName = pName;
prefix = Constants.DEFAULT_NS_PREFIX;
} else {
prefix = pName.substring(0, offset);
uri = pContext.getNamespaceURI(prefix);
if (uri == null || Constants.NULL_NS_URI.equals(uri)) {
if(schema.parent != null && schema.parent.getNamespaceContext() != null) {
uri = schema.parent.getNamespaceContext().getNamespaceURI(prefix);
}
}
if (uri == null || Constants.NULL_NS_URI.equals(uri)) {
throw new IllegalStateException("The prefix " + prefix + " is not bound.");
}
localName = pName.substring(offset+1);
}
return new QName(uri, localName, prefix);
}
/**
* Handle complex types
* @param schema
* @param complexEl
* @param schemaEl
*/
XmlSchemaComplexType handleComplexType(XmlSchema schema,
Element complexEl, Element schemaEl) {
/******
* set the complexTypeName if any
* for( eachChildNode)
* if ( simpleContent)
* if( restrcition)
* handle_simple_content_restriction
* else if( extension)
* handle_simple_content_extension
* break; // it has to be the only child
* else if( complexContent)
* if( restriction)
* handle_complex_content_restriction
* else if( extension)
* handle_complex_content_extension
* break; // it has to be the only child
* else if( group)
* if( group has ref)
* store the group name
* else
* handleGroup
* else if( sequence )
* handleSequence
* else if( all )
* handleAll
* else if(choice)
* handleChoice
* else if(attribute)
* handleAttribute
* else if(attributeGroup)
* handleAttributeGroup
* else if(anyAttribute)
* handleAnyAttribute
*/
XmlSchemaComplexType ct = new XmlSchemaComplexType(schema);
if (complexEl.hasAttribute("name")) {
//String namespace = (schema.targetNamespace==null)?
// "":schema.targetNamespace;
ct.name = complexEl.getAttribute("name");
}
for (Element el = XDOMUtil.getFirstChildElementNS(complexEl,
XmlSchema.SCHEMA_NS)
; el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
//String elPrefix = el.getPrefix() == null ? "" :
//el.getPrefix();
//if(elPrefix.equals(schema.schema_ns_prefix)) {
if (el.getLocalName().equals("sequence")) {
ct.particle = handleSequence(schema,
el, schemaEl);
} else if (el.getLocalName().equals("choice")) {
ct.particle = handleChoice(schema,
el, schemaEl);
} else if (el.getLocalName().equals("all")) {
ct.particle = handleAll(schema, el, schemaEl);
} else if (el.getLocalName().equals("attribute")) {
ct.attributes.add(handleAttribute(schema,
el, schemaEl));
} else if (el.getLocalName().equals("attributeGroup")) {
ct.attributes.add(handleAttributeGroupRef(el));
} else if (el.getLocalName().equals("group")) {
XmlSchemaGroupRef group =
handleGroupRef(schema, el, schemaEl);
ct.particle = (group.particle == null) ?
(XmlSchemaParticle) group : group.particle;
} else if (el.getLocalName().equals("simpleContent")) {
ct.contentModel = handleSimpleContent(schema, el, schemaEl);
} else if (el.getLocalName().equals("complexContent")) {
ct.contentModel = handleComplexContent(schema, el, schemaEl);
} else if (el.getLocalName().equals("annotation")) {
ct.setAnnotation(handleAnnotation(el));
} else if (el.getLocalName().equals("anyAttribute")) {
ct.setAnyAttribute(handleAnyAttribute(schema,el,schemaEl));
}
//}
}
if (complexEl.hasAttribute("block")) {
String blockStr = complexEl.getAttribute("block");
if (blockStr.equalsIgnoreCase("all") |
blockStr.equalsIgnoreCase("#all")) {
ct.setBlock(new XmlSchemaDerivationMethod(Constants.BlockConstants.ALL));
} else
ct.setBlock(new XmlSchemaDerivationMethod(blockStr));
//ct.setBlock(new XmlSchemaDerivationMethod(block));
}
if (complexEl.hasAttribute("final")) {
String finalstr = complexEl.getAttribute("final");
if (finalstr.equalsIgnoreCase("all") |
finalstr.equalsIgnoreCase("#all")) {
ct.setFinal(new XmlSchemaDerivationMethod(Constants.BlockConstants.ALL));
} else
ct.setFinal(new XmlSchemaDerivationMethod(finalstr));
}
if (complexEl.hasAttribute("abstract")) {
String abs = complexEl.getAttribute("abstract");
if (abs.equalsIgnoreCase("true"))
ct.setAbstract(true);
else
ct.setAbstract(false);
}
if (complexEl.hasAttribute("mixed")) {
String mixed = complexEl.getAttribute("mixed");
if (mixed.equalsIgnoreCase("true"))
ct.setMixed(true);
else
ct.setMixed(false);
}
//process extra attributes and elements
processExtensibilityComponents(ct,complexEl);
return ct;
}
private XmlSchemaSimpleContent
handleSimpleContent(XmlSchema schema, Element simpleEl,
Element schemaEl) {
XmlSchemaSimpleContent simpleContent =
new XmlSchemaSimpleContent();
for (Element el = XDOMUtil.getFirstChildElementNS(simpleEl,
XmlSchema.SCHEMA_NS)
; el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
if (el.getLocalName().equals("restriction")) {
simpleContent.content = handleSimpleContentRestriction(schema, el, schemaEl);
} else if (el.getLocalName().equals("extension")) {
simpleContent.content = handleSimpleContentExtension(schema, el, schemaEl);
} else if (el.getLocalName().equals("annotation")) {
simpleContent.setAnnotation(handleAnnotation(el));
}
}
return simpleContent;
}
private XmlSchemaComplexContent handleComplexContent(XmlSchema schema,
Element complexEl,
Element schemaEl) {
XmlSchemaComplexContent complexContent =
new XmlSchemaComplexContent();
for (Element el =
XDOMUtil.getFirstChildElementNS(complexEl, XmlSchema.SCHEMA_NS);
el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
if (el.getLocalName().equals("restriction")) {
complexContent.content = handleComplexContentRestriction(schema, el,
schemaEl);
} else if (el.getLocalName().equals("extension")) {
complexContent.content = handleComplexContentExtension(schema, el,
schemaEl);
} else if (el.getLocalName().equals("annotation")) {
complexContent.setAnnotation(handleAnnotation(el));
}
}
return complexContent;
}
private XmlSchemaSimpleContentRestriction
handleSimpleContentRestriction(XmlSchema schema,
Element restrictionEl, Element schemaEl) {
XmlSchemaSimpleContentRestriction restriction =
new XmlSchemaSimpleContentRestriction();
if (restrictionEl.hasAttribute("base")) {
String name = restrictionEl.getAttribute("base");
restriction.baseTypeName = getRefQName(name, restrictionEl);
}
if (restrictionEl.hasAttribute("id"))
restriction.id = restrictionEl.getAttribute("id");
// check back simpleContent tag children to add attributes and simpleType if any occur
for (
Element el = XDOMUtil.getFirstChildElementNS(restrictionEl,
XmlSchema.SCHEMA_NS)
; el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
if (el.getLocalName().equals("attribute")) {
XmlSchemaAttribute attr =
handleAttribute(schema, el, schemaEl);
restriction.attributes.add(attr);
} else if (el.getLocalName().equals("attributeGroup")) {
XmlSchemaAttributeGroupRef attrGroup =
handleAttributeGroupRef(el);
restriction.attributes.add(attrGroup);
} else if (el.getLocalName().equals("simpleType")) {
restriction.baseType = handleSimpleType(schema, el, schemaEl);
} else if (el.getLocalName().equals("anyAttribute")) {
restriction.anyAttribute =
handleAnyAttribute(schema, el, schemaEl);
} else if (el.getLocalName().equals("annotation")) {
restriction.setAnnotation(handleAnnotation(el));
} else {
XmlSchemaFacet facet = XmlSchemaFacet.construct(el);
NodeList annotations =
el.getElementsByTagNameNS(XmlSchema.SCHEMA_NS, "annotation");
if (annotations.getLength() > 0) {
XmlSchemaAnnotation facetAnnotation =
handleAnnotation(el);
facet.setAnnotation(facetAnnotation);
}
restriction.facets.add(facet);
}
}
return restriction;
}
private XmlSchemaSimpleContentExtension
handleSimpleContentExtension(XmlSchema schema, Element extEl,
Element schemaEl) {
XmlSchemaSimpleContentExtension ext =
new XmlSchemaSimpleContentExtension();
if (extEl.hasAttribute("base")) {
String name = extEl.getAttribute("base");
ext.baseTypeName = getRefQName(name, extEl);
}
for (
Element el = XDOMUtil.getFirstChildElementNS(extEl, XmlSchema.SCHEMA_NS)
; el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
if (el.getLocalName().equals("attribute")) {
XmlSchemaAttribute attr =
handleAttribute(schema, el, schemaEl);
ext.attributes.add(attr);
} else if (el.getLocalName().equals("attributeGroup")) {
XmlSchemaAttributeGroupRef attrGroup =
handleAttributeGroupRef(el);
ext.attributes.add(attrGroup);
} else if (el.getLocalName().equals("anyAttribute")) {
ext.anyAttribute =
handleAnyAttribute(schema, el, schemaEl);
} else if (el.getLocalName().equals("annotation")) {
XmlSchemaAnnotation ann = handleAnnotation(el);
ext.setAnnotation(ann);
}
}
return ext;
}
private XmlSchemaComplexContentRestriction
handleComplexContentRestriction(XmlSchema schema,
Element restrictionEl, Element schemaEl) {
XmlSchemaComplexContentRestriction restriction =
new XmlSchemaComplexContentRestriction();
if (restrictionEl.hasAttribute("base")) {
String name = restrictionEl.getAttribute("base");
restriction.baseTypeName = getRefQName(name, restrictionEl);
}
for (Element el = XDOMUtil.getFirstChildElementNS(restrictionEl,
XmlSchema.SCHEMA_NS)
; el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
if (el.getLocalName().equals("sequence")) {
restriction.particle = handleSequence(schema, el, schemaEl);
} else if (el.getLocalName().equals("choice")) {
restriction.particle = handleChoice(schema, el, schemaEl);
} else if (el.getLocalName().equals("all")) {
restriction.particle = handleAll(schema, el, schemaEl);
} else if (el.getLocalName().equals("attribute")) {
restriction.attributes.add(handleAttribute(schema, el, schemaEl));
} else if (el.getLocalName().equals("attributeGroup")) {
restriction.attributes.add(handleAttributeGroupRef(el));
} else if (el.getLocalName().equals("group")) {
restriction.particle = handleGroupRef(schema, el, schemaEl);
} else if (el.getLocalName().equals("anyAttribute")) {
restriction.anyAttribute =
handleAnyAttribute(schema, el, schemaEl);
} else if (el.getLocalName().equals("annotation")) {
restriction.setAnnotation(handleAnnotation(el));
}
}
return restriction;
}
private XmlSchemaComplexContentExtension
handleComplexContentExtension(XmlSchema schema,
Element extEl, Element schemaEl) {
XmlSchemaComplexContentExtension ext =
new XmlSchemaComplexContentExtension();
if (extEl.hasAttribute("base")) {
String name = extEl.getAttribute("base");
ext.baseTypeName = getRefQName(name, extEl);
}
for (Element el = XDOMUtil.getFirstChildElementNS(extEl, XmlSchema.SCHEMA_NS)
; el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
if (el.getLocalName().equals("sequence")) {
ext.particle = handleSequence(schema, el, schemaEl);
} else if (el.getLocalName().equals("choice")) {
ext.particle = handleChoice(schema, el, schemaEl);
} else if (el.getLocalName().equals("all")) {
ext.particle = handleAll(schema, el, schemaEl);
} else if (el.getLocalName().equals("attribute")) {
ext.attributes.add(handleAttribute(schema, el, schemaEl));
} else if (el.getLocalName().equals("attributeGroup")) {
ext.attributes.add(handleAttributeGroupRef(el));
} else if (el.getLocalName().equals("group")) {
ext.particle = handleGroupRef(schema, el, schemaEl);
} else if (el.getLocalName().equals("anyAttribute")) {
ext.anyAttribute =
handleAnyAttribute(schema, el, schemaEl);
} else if (el.getLocalName().equals("annotation")) {
ext.setAnnotation(handleAnnotation(el));
}
}
return ext;
}
private XmlSchemaAttributeGroupRef
handleAttributeGroupRef(Element attrGroupEl
) {
XmlSchemaAttributeGroupRef attrGroup =
new XmlSchemaAttributeGroupRef();
if (attrGroupEl.hasAttribute("ref")) {
String ref = attrGroupEl.getAttribute("ref");
attrGroup.refName = getRefQName(ref, attrGroupEl);
}
if (attrGroupEl.hasAttribute("id"))
attrGroup.id = attrGroupEl.getAttribute("id");
Element annotationEl =
XDOMUtil.getFirstChildElementNS(attrGroupEl,
XmlSchema.SCHEMA_NS, "annotation");
if (annotationEl != null) {
XmlSchemaAnnotation annotation = handleAnnotation(annotationEl);
attrGroup.setAnnotation(annotation);
}
return attrGroup;
}
private XmlSchemaSequence handleSequence(XmlSchema schema,
Element sequenceEl,
Element schemaEl) {
XmlSchemaSequence sequence = new XmlSchemaSequence();
for (Element el = XDOMUtil.getFirstChildElementNS(sequenceEl, XmlSchema.SCHEMA_NS)
; el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
if (el.getLocalName().equals("sequence")) {
XmlSchemaSequence seq = handleSequence(schema, el,
schemaEl);
sequence.items.add(seq);
} else if (el.getLocalName().equals("element")) {
XmlSchemaElement element = handleElement(schema, el,
schemaEl, false);
sequence.items.add(element);
} else if (el.getLocalName().equals("group")) {
XmlSchemaGroupRef group = handleGroupRef(schema, el,
schemaEl);
sequence.items.add(group);
} else if (el.getLocalName().equals("choice")) {
XmlSchemaChoice choice = handleChoice(schema, el,
schemaEl);
sequence.items.add(choice);
} else if (el.getLocalName().equals("any")) {
XmlSchemaAny any = handleAny(schema, el, schemaEl);
sequence.items.add(any);
} else if (el.getLocalName().equals("annotation")) {
XmlSchemaAnnotation annotation = handleAnnotation(el);
sequence.setAnnotation(annotation);
}
}
return sequence;
}
/** @noinspection UnusedParameters*/
private XmlSchemaAny handleAny(XmlSchema schema,
Element anyEl,
Element schemaEl) {
XmlSchemaAny any = new XmlSchemaAny();
if (anyEl.hasAttribute("namespace"))
any.namespace = anyEl.getAttribute("namespace");
if (anyEl.hasAttribute("processContents")) {
String processContent = getEnumString(anyEl,
"processContents");
any.processContent =
new XmlSchemaContentProcessing(processContent);
}
Element annotationEl = XDOMUtil.getFirstChildElementNS(anyEl,
XmlSchema.SCHEMA_NS, "annotation");
if (annotationEl != null) {
XmlSchemaAnnotation annotation =
handleAnnotation(annotationEl);
any.setAnnotation(annotation);
}
any.minOccurs = getMinOccurs(anyEl);
any.maxOccurs = getMaxOccurs(anyEl);
return any;
}
private XmlSchemaChoice handleChoice(XmlSchema schema, Element choiceEl,
Element schemaEl) {
XmlSchemaChoice choice = new XmlSchemaChoice();
if (choiceEl.hasAttribute("id"))
choice.id = choiceEl.getAttribute("id");
choice.minOccurs = getMinOccurs(choiceEl);
choice.maxOccurs = getMaxOccurs(choiceEl);
for (Element el = XDOMUtil.getFirstChildElementNS(choiceEl,
XmlSchema.SCHEMA_NS)
; el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
if (el.getLocalName().equals("sequence")) {
XmlSchemaSequence seq =
handleSequence(schema, el, schemaEl);
choice.items.add(seq);
} else if (el.getLocalName().equals("element")) {
XmlSchemaElement element =
handleElement(schema, el, schemaEl, false);
choice.items.add(element);
} else if (el.getLocalName().equals("group")) {
XmlSchemaGroupRef group =
handleGroupRef(schema, el, schemaEl);
choice.items.add(group);
} else if (el.getLocalName().equals("choice")) {
XmlSchemaChoice choiceItem =
handleChoice(schema, el, schemaEl);
choice.items.add(choiceItem);
} else if (el.getLocalName().equals("any")) {
XmlSchemaAny any = handleAny(schema, el, schemaEl);
choice.items.add(any);
} else if (el.getLocalName().equals("annotation")) {
XmlSchemaAnnotation annotation = handleAnnotation(el);
choice.setAnnotation(annotation);
}
}
return choice;
}
private XmlSchemaAll handleAll(XmlSchema schema, Element allEl,
Element schemaEl) {
XmlSchemaAll all = new XmlSchemaAll();
for (Element el = XDOMUtil.getFirstChildElementNS(allEl, XmlSchema.SCHEMA_NS);
el != null; el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
if (el.getLocalName().equals("element")) {
XmlSchemaElement element = handleElement(schema, el, schemaEl, false);
all.items.add(element);
} else if (el.getLocalName().equals("annotation")) {
XmlSchemaAnnotation annotation = handleAnnotation(el);
all.setAnnotation(annotation);
}
}
return all;
}
private XmlSchemaGroup handleGroup(XmlSchema schema, Element groupEl,
Element schemaEl) {
XmlSchemaGroup group = new XmlSchemaGroup();
group.name = groupEl.getAttribute("name");
for (Element el = XDOMUtil.getFirstChildElementNS(groupEl,
XmlSchema.SCHEMA_NS);
el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
if (el.getLocalName().equals("all")) {
group.particle = handleAll(schema, el, schemaEl);
} else if (el.getLocalName().equals("sequence")) {
group.particle = handleSequence(schema, el, schemaEl);
} else if (el.getLocalName().equals("choice")) {
group.particle = handleChoice(schema, el, schemaEl);
} else if (el.getLocalName().equals("annotation")) {
XmlSchemaAnnotation groupAnnotation =
handleAnnotation(el);
group.setAnnotation(groupAnnotation);
}
}
return group;
}
private XmlSchemaAttributeGroup handleAttributeGroup(XmlSchema schema,
Element groupEl,
Element schemaEl) {
XmlSchemaAttributeGroup attrGroup =
new XmlSchemaAttributeGroup();
if (groupEl.hasAttribute("name"))
attrGroup.name = groupEl.getAttribute("name");
if (groupEl.hasAttribute("id"))
attrGroup.id = groupEl.getAttribute("id");
for (Element el = XDOMUtil.getFirstChildElementNS(groupEl,
XmlSchema.SCHEMA_NS);
el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
if (el.getLocalName().equals("attribute")) {
XmlSchemaAttribute attr =
handleAttribute(schema, el, schemaEl);
attrGroup.attributes.add(attr);
} else if (el.getLocalName().equals("attributeGroup")) {
XmlSchemaAttributeGroupRef attrGroupRef =
handleAttributeGroupRef(el);
attrGroup.attributes.add(attrGroupRef);
} else if (el.getLocalName().equals("anyAttribute")) {
attrGroup.anyAttribute = handleAnyAttribute(schema,
el, schemaEl);
} else if (el.getLocalName().equals("annotation")) {
XmlSchemaAnnotation ann = handleAnnotation(el);
attrGroup.setAnnotation(ann);
}
}
return attrGroup;
}
/** @noinspection UnusedParameters*/
private XmlSchemaAnyAttribute handleAnyAttribute(XmlSchema schema,
Element anyAttrEl,
Element schemaEl) {
XmlSchemaAnyAttribute anyAttr = new XmlSchemaAnyAttribute();
if (anyAttrEl.hasAttribute("namespace"))
anyAttr.namespace = anyAttrEl.getAttribute("namespace");
if (anyAttrEl.hasAttribute("processContents")) {
String contentProcessing = getEnumString(anyAttrEl,
"processContents");
anyAttr.processContent = new XmlSchemaContentProcessing(contentProcessing);
}
if (anyAttrEl.hasAttribute("id"))
anyAttr.id = anyAttrEl.getAttribute("id");
Element annotationEl =
XDOMUtil.getFirstChildElementNS(anyAttrEl,
XmlSchema.SCHEMA_NS, "annotation");
if (annotationEl != null) {
XmlSchemaAnnotation annotation =
handleAnnotation(annotationEl);
anyAttr.setAnnotation(annotation);
}
return anyAttr;
}
private XmlSchemaGroupRef handleGroupRef(XmlSchema schema,
Element groupEl, Element schemaEl) {
XmlSchemaGroupRef group = new XmlSchemaGroupRef();
Element annotationEl = XDOMUtil.getFirstChildElementNS(groupEl,
XmlSchema.SCHEMA_NS,
"annotation");
if (annotationEl != null) {
XmlSchemaAnnotation annotation =
handleAnnotation(annotationEl);
group.setAnnotation(annotation);
}
if (groupEl.hasAttribute("ref")) {
String ref = groupEl.getAttribute("ref");
group.refName = getRefQName(ref, groupEl);
return group;
}
for (Element el = XDOMUtil.getFirstChildElementNS(groupEl,
XmlSchema.SCHEMA_NS)
; el != null;
el = XDOMUtil.getNextSiblingElement(el)) {
if (el.getLocalName().equals("sequence")) {
group.particle = handleSequence(schema, el, schemaEl);
} else if (el.getLocalName().equals("all")) {
group.particle = handleAll(schema, el, schemaEl);
} else if (el.getLocalName().equals("choice")) {
group.particle = handleChoice(schema, el,
schemaEl);
}
}
return group;
}
private QName newLocalQName(String pLocalName) {
String uri = schema.logicalTargetNamespace;
if (uri == null) {
uri = Constants.NULL_NS_URI;
}
return new QName(uri, pLocalName);
}
private XmlSchemaAttribute handleAttribute(XmlSchema schema,
Element attrEl, Element schemaEl) {
//todo: need to implement different rule of attribute such as
//restriction between ref and name. This can be implemented
//in the compile function
XmlSchemaAttribute attr = new XmlSchemaAttribute();
if (attrEl.hasAttribute("name")) {
String name = attrEl.getAttribute("name");
//String namespace = (schema.targetNamespace==null)?
// "" :schema.targetNamespace;
attr.name = name;
}
boolean isQualified = schema.getAttributeFormDefault().getValue().equals(XmlSchemaForm.QUALIFIED);
if (attr.name != null) {
final String name = attr.name;
attr.qualifiedName = (isQualified) ? newLocalQName(name) : new QName(name);
}
if (attrEl.hasAttribute("type")) {
String name = attrEl.getAttribute("type");
attr.schemaTypeName = getRefQName(name, attrEl);
}
if (attrEl.hasAttribute("default"))
attr.defaultValue = attrEl.getAttribute("default");
if (attrEl.hasAttribute("fixed"))
attr.fixedValue = attrEl.getAttribute("fixed");
if (attrEl.hasAttribute("form")) {
String formValue = getEnumString(attrEl, "form");
attr.form = new XmlSchemaForm(formValue);
}
if (attrEl.hasAttribute("id"))
attr.id = attrEl.getAttribute("id");
if (attrEl.hasAttribute("use")) {
String useType = getEnumString(attrEl, "use");
attr.use = new XmlSchemaUse(useType);
}
if (attrEl.hasAttribute("ref")) {
String name = attrEl.getAttribute("ref");
attr.refName = getRefQName(name, attrEl);
attr.name = name;
}
Element simpleTypeEl =
XDOMUtil.getFirstChildElementNS(attrEl,
XmlSchema.SCHEMA_NS, "simpleType");
if (simpleTypeEl != null) {
attr.schemaType = handleSimpleType(schema, simpleTypeEl,
schemaEl);
}
Element annotationEl =
XDOMUtil.getFirstChildElementNS(attrEl,
XmlSchema.SCHEMA_NS, "annotation");
if (annotationEl != null) {
XmlSchemaAnnotation annotation =
handleAnnotation(annotationEl);
attr.setAnnotation(annotation);
}
NamedNodeMap attrNodes = attrEl.getAttributes();
Vector attrs = new Vector();
NodeNamespaceContext ctx = null;
for (int i = 0; i < attrNodes.getLength(); i++) {
Attr att = (Attr) attrNodes.item(i);
String attName = att.getName();
if (!attName.equals("name") &&
!attName.equals("type") &&
!attName.equals("default") &&
!attName.equals("fixed") &&
!attName.equals("form") &&
!attName.equals("id") &&
!attName.equals("use") &&
!attName.equals("ref")) {
attrs.add(att);
String value = att.getValue();
if (value.indexOf(":") > -1) {
// there is a possiblily of some namespace mapping
String prefix = value.substring(0, value.indexOf(":"));
if (ctx == null) {
ctx = new NodeNamespaceContext(attrEl);
}
String namespace = ctx.getNamespaceURI(prefix);
if (!Constants.NULL_NS_URI.equals(namespace)) {
Attr nsAttr = attrEl.getOwnerDocument().createAttribute("xmlns:" + prefix);
nsAttr.setValue(namespace);
attrs.add(nsAttr);
}
}
}
}
if (attrs.size() > 0)
attr.setUnhandledAttributes((Attr[]) attrs.toArray(new Attr[0]));
return attr;
}
/*
* handle_simple_content_restriction
*
* if( restriction has base attribute )
* set the baseType
* else if( restriciton has an inline simpleType )
* handleSimpleType
* add facets if any to the restriction
*/
/*
* handle_simple_content_extension
*
* extension should have a base name and cannot have any inline defn
* for( each childNode )
* if( attribute)
* handleAttribute
* else if( attributeGroup)
* handleAttributeGroup
* else if( anyAttribute)
* handleAnyAttribute
*/
/*
* ********
* handle_complex_content_restriction
*/
/**
* handle elements
* @param schema
* @param el
* @param schemaEl
* @param isGlobal
*/
XmlSchemaElement handleElement(XmlSchema schema,
Element el,
Element schemaEl,
boolean isGlobal) {
XmlSchemaElement element = new XmlSchemaElement();
if (el.getAttributeNode("name") != null)
element.name = el.getAttribute("name");
// String namespace = (schema.targetNamespace==null)?
// "" : schema.targetNamespace;
boolean isQualified = schema.getElementFormDefault().getValue().equals(XmlSchemaForm.QUALIFIED);
if (el.hasAttribute("form")) {
String formDef = el.getAttribute("form");
element.form = new XmlSchemaForm(formDef);
isQualified = formDef.equals(XmlSchemaForm.QUALIFIED);
}
if (element.name != null) {
final String name = element.name;
element.qualifiedName = (isQualified || isGlobal) ? newLocalQName(name) : new QName(Constants.NULL_NS_URI, name);
}
Element annotationEl =
XDOMUtil.getFirstChildElementNS(el,
XmlSchema.SCHEMA_NS,
"annotation");
if (annotationEl != null) {
XmlSchemaAnnotation annotation =
handleAnnotation(annotationEl);
element.setAnnotation(annotation);
}
if (el.getAttributeNode("type") != null) {
String typeName = el.getAttribute("type");
QName typeQName = element.schemaTypeName = getRefQName(typeName, el);
XmlSchemaType type = collection.getTypeByQName(typeQName);
if (type == null) {
// Could be a forward reference...
collection.addUnresolvedType(typeQName, element);
}
element.schemaType = type;
} else if (el.getAttributeNode("ref") != null) {
String refName = el.getAttribute("ref");
element.setRefName(getRefQName(refName, el));
element.name = refName;
}
Element simpleTypeEl, complexTypeEl, keyEl, keyrefEl, uniqueEl;
if ((simpleTypeEl = XDOMUtil.getFirstChildElementNS(el,
XmlSchema.SCHEMA_NS, "simpleType")) != null) {
XmlSchemaSimpleType simpleType =
handleSimpleType(schema, simpleTypeEl, schemaEl);
element.schemaType = simpleType;
element.schemaTypeName = simpleType.getQName();
} else if ((complexTypeEl =
XDOMUtil.getFirstChildElementNS(el, XmlSchema.SCHEMA_NS,
"complexType")) != null) {
element.schemaType = handleComplexType(schema, complexTypeEl, schemaEl);
}
if ((keyEl =
XDOMUtil.getFirstChildElementNS(el, XmlSchema.SCHEMA_NS, "key")) != null) {
element.constraints.add(handleConstraint(keyEl, "Key"));
}
if ((keyrefEl = XDOMUtil.getFirstChildElementNS(el, XmlSchema.SCHEMA_NS, "keyref")) != null) {
XmlSchemaKeyref keyRef =
(XmlSchemaKeyref) handleConstraint(keyrefEl,
"Keyref");
if (el.hasAttribute("refer")) {
String name = el.getAttribute("refer");
keyRef.refer = getRefQName(name, el);
}
element.constraints.add(keyRef);
}
if ((uniqueEl =
XDOMUtil.getFirstChildElementNS(el,
XmlSchema.SCHEMA_NS, "unique")) != null) {
element.constraints.add(handleConstraint(uniqueEl, "Unique"));
}
if (el.hasAttribute("abstract")) {
element.isAbstract =
Boolean.valueOf(el.getAttribute("abstract")).booleanValue();
}
if (el.hasAttribute("block"))
element.block = getDerivation(el, "block");
if (el.hasAttribute("default"))
element.defaultValue = el.getAttribute("default");
if (el.hasAttribute("final"))
element.finalDerivation = getDerivation(el, "final");
if (el.hasAttribute("fixed"))
element.fixedValue = el.getAttribute("fixed");
if (el.hasAttribute("id"))
element.id = el.getAttribute("id");
if (el.hasAttribute("nillable"))
element.isNillable =
Boolean.valueOf(el.getAttribute("nillable")).booleanValue();
if (el.hasAttribute("substitutionGroup")) {
String substitutionGroup = el.getAttribute("substitutionGroup");
element.setSubstitutionGroup(getRefQName(substitutionGroup, el));
}
element.minOccurs = getMinOccurs(el);
element.maxOccurs = getMaxOccurs(el);
//process extra attributes and elements
processExtensibilityComponents(element,el);
return element;
}
private XmlSchemaIdentityConstraint handleConstraint(
Element constraintEl, String type) {
try {
XmlSchemaIdentityConstraint constraint =
(XmlSchemaIdentityConstraint) Class.forName("org.apache.ws.commons.schema.XmlSchema" + type).newInstance();
if (constraintEl.hasAttribute("name"))
constraint.name = constraintEl.getAttribute("name");
if (constraintEl.hasAttribute("refer")) {
String name = constraintEl.getAttribute("refer");
((XmlSchemaKeyref) constraint).refer = getRefQName(name, constraintEl);
}
for (Element el = XDOMUtil.getFirstChildElementNS(constraintEl,
XmlSchema.SCHEMA_NS);
el != null;
el = XDOMUtil.getNextSiblingElementNS(el, XmlSchema.SCHEMA_NS)) {
// String elPrefix = el.getPrefix() == null ? ""
// : el.getPrefix();
//if(elPrefix.equals(schema.schema_ns_prefix)) {
if (el.getLocalName().equals("selector")) {
XmlSchemaXPath selectorXPath =
new XmlSchemaXPath();
selectorXPath.xpath = el.getAttribute("xpath");
Element annotationEl =
XDOMUtil.getFirstChildElementNS(el, XmlSchema.SCHEMA_NS,
"annotation");
if (annotationEl != null) {
XmlSchemaAnnotation annotation =
handleAnnotation(annotationEl);
selectorXPath.setAnnotation(annotation);
}
constraint.selector = selectorXPath;
} else if (el.getLocalName().equals("field")) {
XmlSchemaXPath fieldXPath = new XmlSchemaXPath();
fieldXPath.xpath = el.getAttribute("xpath");
constraint.fields.add(fieldXPath);
Element annotationEl =
XDOMUtil.getFirstChildElementNS(el, XmlSchema.SCHEMA_NS,
"annotation");
if (annotationEl != null) {
XmlSchemaAnnotation annotation =
handleAnnotation(annotationEl);
fieldXPath.setAnnotation(annotation);
}
} else if (el.getLocalName().equals("annotation")) {
XmlSchemaAnnotation constraintAnnotation =
handleAnnotation(el);
constraint.setAnnotation(constraintAnnotation);
}
}
return constraint;
} catch (ClassNotFoundException e) {
throw new XmlSchemaException(e.getMessage());
} catch (InstantiationException e) {
throw new XmlSchemaException(e.getMessage());
} catch (IllegalAccessException e) {
throw new XmlSchemaException(e.getMessage());
}
}
XmlSchemaImport handleImport(XmlSchema schema, Element importEl,
Element schemaEl) {
XmlSchemaImport schemaImport = new XmlSchemaImport();
Element annotationEl =
XDOMUtil.getFirstChildElementNS(importEl, XmlSchema.SCHEMA_NS, "annotation");
if (annotationEl != null) {
XmlSchemaAnnotation importAnnotation =
handleAnnotation(annotationEl);
schemaImport.setAnnotation(importAnnotation);
}
final String uri = schemaImport.namespace = importEl.getAttribute("namespace");
schemaImport.schemaLocation =
importEl.getAttribute("schemaLocation");
TargetNamespaceValidator validator = new TargetNamespaceValidator(){
private boolean isEmpty(String pValue) {
return pValue == null || Constants.NULL_NS_URI.equals(pValue);
}
public void validate(XmlSchema pSchema) {
final boolean valid;
if (isEmpty(uri)) {
valid = isEmpty(pSchema.syntacticalTargetNamespace);
} else {
valid = pSchema.syntacticalTargetNamespace.equals(uri);
}
if (!valid) {
throw new XmlSchemaException("An imported schema was announced to have the namespace "
+ uri + ", but has the namespace " +
pSchema.syntacticalTargetNamespace);
}
}
};
if ((schemaImport.schemaLocation != null) && (!schemaImport.schemaLocation.equals(""))) {
if(schema.getSourceURI()!=null) {
schemaImport.schema =
resolveXmlSchema(
uri,
schemaImport.schemaLocation,
schema.getSourceURI(),
validator);
} else {
schemaImport.schema =
resolveXmlSchema(
schemaImport.namespace,
schemaImport.schemaLocation,
validator);
}
}
return schemaImport;
}
/**
* Handles the include
* @param schema
* @param includeEl
* @param schemaEl
*/
XmlSchemaInclude handleInclude(final XmlSchema schema,
Element includeEl, Element schemaEl) {
XmlSchemaInclude include = new XmlSchemaInclude();
Element annotationEl =
XDOMUtil.getFirstChildElementNS(includeEl,
XmlSchema.SCHEMA_NS, "annotation");
if (annotationEl != null) {
XmlSchemaAnnotation includeAnnotation =
handleAnnotation(annotationEl);
include.setAnnotation(includeAnnotation);
}
include.schemaLocation =
includeEl.getAttribute("schemaLocation");
//includes are not supposed to have a target namespace
// we should be passing in a null in place of the target
//namespace
final TargetNamespaceValidator validator = newIncludeValidator(schema);
if(schema.getSourceURI()!=null) {
include.schema =
resolveXmlSchema(
schema.logicalTargetNamespace,
include.schemaLocation,
schema.getSourceURI(),
validator);
} else {
include.schema =
resolveXmlSchema(
schema.logicalTargetNamespace,
include.schemaLocation,
validator);
}
//process extra attributes and elements
processExtensibilityComponents(include,includeEl);
return include;
}
private TargetNamespaceValidator newIncludeValidator(final XmlSchema schema) {
return new TargetNamespaceValidator(){
private boolean isEmpty(String pValue) {
return pValue == null || Constants.NULL_NS_URI.equals(pValue);
}
public void validate(XmlSchema pSchema) {
if (isEmpty(pSchema.syntacticalTargetNamespace)) {
pSchema.logicalTargetNamespace = schema.logicalTargetNamespace;
} else {
if (!pSchema.syntacticalTargetNamespace.equals(schema.logicalTargetNamespace)) {
String msg = "An included schema was announced to have the default target namespace";
if (!isEmpty(schema.logicalTargetNamespace)) {
msg += " or the target namespace " + schema.logicalTargetNamespace;
}
throw new XmlSchemaException(msg + ", but has the target namespace "
+ pSchema.logicalTargetNamespace);
}
}
}
};
}
/**
* Handles the annotation
* Traversing if encounter appinfo or documentation
* add it to annotation collection
*
*/
XmlSchemaAnnotation handleAnnotation(Element annotEl) {
XmlSchemaObjectCollection content = new XmlSchemaObjectCollection();
XmlSchemaAppInfo appInfoObj;
XmlSchemaDocumentation docsObj;
for (Element appinfo = XDOMUtil.getFirstChildElementNS(annotEl,
XmlSchema.SCHEMA_NS, "appinfo");
appinfo != null;
appinfo = XDOMUtil.getNextSiblingElementNS(appinfo, XmlSchema.SCHEMA_NS, "appinfo")) {
appInfoObj = handleAppInfo(appinfo);
if (appInfoObj != null) {
content.add(appInfoObj);
}
}
for (Element documentation = XDOMUtil.getFirstChildElementNS(annotEl,
XmlSchema.SCHEMA_NS, "documentation");
documentation != null;
documentation = XDOMUtil.getNextSiblingElementNS(documentation,
XmlSchema.SCHEMA_NS, "documentation")) {
docsObj = handleDocumentation(documentation);
if (docsObj != null) {
content.add(docsObj);
}
}
XmlSchemaAnnotation annotation = new XmlSchemaAnnotation();
annotation.items = content;
//process extra attributes and elements
processExtensibilityComponents(annotation,annotEl);
return annotation;
}
/**
* create new XmlSchemaAppinfo and add value goten from element
* to this obj
* @param content
*/
XmlSchemaAppInfo handleAppInfo(Element content) {
XmlSchemaAppInfo appInfo = new XmlSchemaAppInfo();
NodeList markup = getChild(content);
if (!content.hasAttribute("source") &&
(markup == null || markup.getLength() <= 0)) {
return null;
}
appInfo.setSource(getAttribute(content, "source"));
appInfo.setMarkup(markup);
return appInfo;
}
//iterate each documentation element, create new XmlSchemaAppinfo and add to collection
XmlSchemaDocumentation handleDocumentation(Element content) {
XmlSchemaDocumentation documentation = new XmlSchemaDocumentation();
NodeList markup = getChild(content);
if (!content.hasAttribute("source") &&
!content.hasAttribute("xml:lang") &&
(markup == null || markup.getLength() <= 0))
return null;
documentation.setSource(getAttribute(content, "source"));
documentation.setLanguage(getAttribute(content, "xml:lang"));
documentation.setMarkup(getChild(content));
return documentation;
}
private String getAttribute(Element content, String attrName) {
if (content.hasAttribute(attrName))
return content.getAttribute(attrName);
return null;
}
private NodeList getChild(Element content) {
NodeList childs = content.getChildNodes();
if (childs.getLength() > 0)
return childs;
return null;
}
long getMinOccurs(Element el) {
try {
if (el.getAttributeNode("minOccurs") != null) {
String value = el.getAttribute("minOccurs");
if (value.equals("unbounded"))
return Long.MAX_VALUE;
else
return Long.parseLong(value);
}
return 1;
} catch (java.lang.NumberFormatException e) {
return 1;
}
}
long getMaxOccurs(Element el) {
try {
if (el.getAttributeNode("maxOccurs") != null) {
String value = el.getAttribute("maxOccurs");
if (value.equals("unbounded"))
return Long.MAX_VALUE;
else
return Long.parseLong(value);
}
return 1;
} catch (java.lang.NumberFormatException e) {
return 1;
}
}
XmlSchemaForm getFormDefault(Element el, String attrName) {
if (el.getAttributeNode(attrName) != null) {
String value = el.getAttribute(attrName);
return new XmlSchemaForm(value);
} else
return new XmlSchemaForm("unqualified");
}
//Check value entered by user and change according to .net spec,
//according to w3c spec have to be "#all"
//but in .net the valid enum value is "all".
XmlSchemaDerivationMethod getDerivation(Element el, String attrName) {
if (el.hasAttribute(attrName) && !el.getAttribute(attrName).equals("")) {
//#all | List of (extension | restriction | substitution
String derivationMethod = el.getAttribute(attrName).trim();
if (derivationMethod.equals("#all"))
return new XmlSchemaDerivationMethod(Constants.BlockConstants.ALL);
else
return new XmlSchemaDerivationMethod(derivationMethod);
}
return new XmlSchemaDerivationMethod(Constants.BlockConstants.NONE);
}
//Check value entered by user and change according to .net spec, user
String getEnumString(Element el, String attrName) {
if (el.hasAttribute(attrName)) {
return el.getAttribute(attrName).trim();
}
return Constants.BlockConstants.NONE;
}
/**
* Resolve the schemas
* @param targetNamespace
* @param schemaLocation
*/
XmlSchema resolveXmlSchema(String targetNamespace,
String schemaLocation,
String baseUri,
TargetNamespaceValidator validator) {
//use the entity resolver provided
InputSource source = collection.schemaResolver.
resolveEntity(targetNamespace,schemaLocation,baseUri);
final String systemId = source.getSystemId() == null ? schemaLocation : source.getSystemId();
final SchemaKey key = new XmlSchemaCollection.SchemaKey(targetNamespace, systemId);
XmlSchema schema = collection.getSchema(key);
if (schema != null) {
return schema;
}
try {
return collection.read(source, null, validator);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* Resolve the schemas
* @param targetNamespace
* @param schemaLocation
*/
XmlSchema resolveXmlSchema(String targetNamespace,
String schemaLocation,
TargetNamespaceValidator validator) {
return resolveXmlSchema(targetNamespace, schemaLocation,
collection.baseUri, validator);
}
/**
* A generic method to process the extra attributes and the the extra
* elements present within the schema.
* What it does right now is to attach extra attributes to a map
* having QName/value pairs and store the map in the metadata section
* of the schema object
* @param schemaObject
* @param elt
*/
private void processExtensibilityComponents(XmlSchemaObject schemaObject,Element elt){
Map attribMap = new HashMap();
NamedNodeMap attributes = elt.getAttributes();
for (int i=0 ;i < attributes.getLength();i++){
Attr attribute = (Attr)attributes.item(i);
String namespaceURI = attribute.getNamespaceURI();
String name = attribute.getName();
if (namespaceURI!= null &&
!"".equals(namespaceURI) && //ignore unqualified attributes
!name.startsWith(Constants.XMLNS_ATTRIBUTE) && //ignore namespaces
!Constants.URI_2001_SCHEMA_XSD.equals(namespaceURI)){
attribMap.put(new QName(namespaceURI,name),
attribute.getValue());
}
}
if (!attribMap.isEmpty()){
schemaObject.addMetaInfo(
Constants.MetaDataConstants.EXTERNAL_ATTRIBUTES,
attribMap
);
}
}
}