| /* |
| * Copyright (c) 2010 JBoss, Inc. and others |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| */ |
| package org.eclipse.bpel.model.util; |
| |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| import java.util.Hashtable; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Stack; |
| |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.xsd.XSDAttributeDeclaration; |
| import org.eclipse.xsd.XSDAttributeGroupContent; |
| import org.eclipse.xsd.XSDAttributeGroupDefinition; |
| import org.eclipse.xsd.XSDAttributeUse; |
| import org.eclipse.xsd.XSDComplexTypeDefinition; |
| import org.eclipse.xsd.XSDConcreteComponent; |
| import org.eclipse.xsd.XSDDiagnostic; |
| import org.eclipse.xsd.XSDDiagnosticSeverity; |
| import org.eclipse.xsd.XSDElementDeclaration; |
| import org.eclipse.xsd.XSDFactory; |
| import org.eclipse.xsd.XSDModelGroup; |
| import org.eclipse.xsd.XSDModelGroupDefinition; |
| import org.eclipse.xsd.XSDNamedComponent; |
| import org.eclipse.xsd.XSDParticle; |
| import org.eclipse.xsd.XSDParticleContent; |
| import org.eclipse.xsd.XSDSimpleTypeDefinition; |
| import org.eclipse.xsd.XSDTerm; |
| import org.eclipse.xsd.XSDTypeDefinition; |
| import org.eclipse.xsd.XSDWildcard; |
| import org.eclipse.xsd.util.XSDConstants; |
| |
| /** |
| * Compares two XSD fragments for structure and data type compatibility. |
| * Optional components in either the left or right schema may be skipped |
| * over during the comparison unless a strict match is requested (see |
| * <code>setStrict()<code>). |
| * |
| * Components which have a "minOccurs" of 0 are considered optional. |
| * Wildcard components (<xsd:any> elements) will match any component |
| * in the other schema. |
| * |
| * After the comparison, diagnostics are available which indicate the |
| * components in the left and right schema that do not match. Warning |
| * diagnostics are generated whenever optional components were skipped |
| * to force a match. |
| * |
| * @see https://jira.jboss.org/browse/JBIDE-7351 |
| * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| * @author Bob Brodt |
| * @date Oct 29, 2010 |
| */ |
| public class XSDComparer { |
| |
| protected boolean strict = false; |
| protected boolean debug = false; |
| protected List<XSDDiagnostic> diagnostics; |
| protected Hashtable<XSDTerm,XSDTerm> terms = new Hashtable<XSDTerm,XSDTerm>(); |
| |
| public void setStrict(boolean flag) { |
| strict = flag; |
| } |
| |
| public void setDebug(boolean flag) { |
| debug = flag; |
| } |
| |
| protected boolean alreadyCompared(XSDTerm term1, XSDTerm term2) { |
| XSDTerm t = terms.get(term1); |
| if (t==term2) |
| return true; |
| t = terms.get(term2); |
| if (t==term1) |
| return true; |
| return false; |
| } |
| |
| /** |
| * The main comparison function that compares two XSD type definitions. |
| * These may be the entire schema or just fragments within a schema. |
| * |
| * @param type1 - the "left" type definition |
| * @param type2 - the "right" type definition |
| * @return true if the types are compatible, false if not. |
| * Warning diagnostics may still be generated for a successful match. |
| */ |
| public boolean compare(XSDTypeDefinition type1, XSDTypeDefinition type2) { |
| boolean result = false; |
| if (type1==null || type2==null) |
| throw new IllegalArgumentException("XSDComparer: XSD types may not be null"); |
| |
| try { |
| // always clear out diagnostics before we start |
| if (diagnostics!=null) |
| diagnostics.clear(); |
| |
| // for debugging only: run through the exercises even if the |
| // two objects are one and the same |
| if (!debug && type1==type2) |
| return true; |
| |
| result = compare(getChildTerms(type1), getChildTerms(type2), 0); |
| } catch (Exception e) { |
| return false; |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Compares a list of the immediate children of a component; called recursively |
| * for children that are complex elements. |
| * |
| * @param list1 - children of the "left" schema |
| * @param list2 - children of the "right" schema |
| * @param level - recursion level (for debug printing) |
| * @return true if the left and right children lists are compatible. |
| */ |
| protected boolean compare(List<XSDTerm> list1, List<XSDTerm> list2, int level) { |
| |
| XSDTerm term1 = null; |
| XSDTerm term2 = null; |
| |
| try { |
| int index1 = 0; |
| int index2 = 0; |
| int size1 = list1.size(); |
| int size2 = list2.size(); |
| while (index1 < size1 && index2 < size2) { |
| term1 = list1.get(index1); |
| term2 = list2.get(index2); |
| if (alreadyCompared(term1,term2)) { |
| dump("Skipping ",term1,null,level); |
| } |
| else { |
| terms.put(term1,term2); |
| if ( term1 instanceof XSDElementDeclaration && term2 instanceof XSDElementDeclaration) { |
| XSDElementDeclaration elem1 = (XSDElementDeclaration)term1; |
| XSDElementDeclaration elem2 = (XSDElementDeclaration)term2; |
| XSDTypeDefinition type1 = elem1.getTypeDefinition(); |
| XSDTypeDefinition type2 = elem2.getTypeDefinition(); |
| if (type1 instanceof XSDSimpleTypeDefinition && type2 instanceof XSDSimpleTypeDefinition) { |
| dump("Comparing ", elem1, type1, level); |
| dump(" to ", elem2, type2, level); |
| if (!compareQNames(elem1, elem2)) { |
| addError("different QNames: " + elem1.getQName() + " vs " + elem2.getQName(), term1,term2); |
| return false; |
| } |
| String s1 = getTypeNameHierarchy(elem1); |
| String s2 = getTypeNameHierarchy(elem2); |
| if (!s1.equals(s2)) { |
| addError("different data types: "+s1+" vs "+s2,elem1,elem2); |
| return false; |
| } |
| } else if (type1 instanceof XSDComplexTypeDefinition && type2 instanceof XSDComplexTypeDefinition) { |
| dump("Comparing ", elem1, type1, level); |
| dump(" to ", elem2, type2, level); |
| if (!compareQNames(elem1, elem2)) { |
| addError("different QNames: " + elem1.getQName() + " vs " + elem2.getQName(), term1,term2); |
| return false; |
| } |
| int min1 = getMinOccurs(term1); |
| int min2 = getMinOccurs(term2); |
| int max1 = getMaxOccurs(term1); |
| int max2 = getMaxOccurs(term2); |
| if (strict) { |
| if (min1 != min2 || max1 != max2) { |
| addError("different cardinality: " + min1 + " to " + max1 + " vs " + min2 + " to " + max2, term1,term2); |
| return false; |
| } |
| } else { |
| if ((max2>0 && min1 > max2) || (max1>0 && min2 > max1)) { |
| addError("incompatible cardinality: " + min1 + " to " + max1 + " vs " + min2 + " to " + max2, term1,term2); |
| return false; |
| } |
| } |
| boolean result = compare(getChildTerms(elem1), getChildTerms(elem2), level + 1); |
| if (!result) { |
| addError("different complex element structures",elem1,elem2); |
| return false; |
| } |
| } else { |
| if (!strict) { |
| // try shifting optional elements and continue from there |
| dump("Elements out of sync - skipping optional elements"); |
| if (isOptional(elem1)) { |
| // skip over this one and compare remaining elements |
| List<XSDTerm> newList1 = new ArrayList<XSDTerm>(); |
| List<XSDTerm> newList2 = new ArrayList<XSDTerm>(); |
| for (int i = index1 + 1; i < size1; ++i) |
| newList1.add(list1.get(i)); |
| for (int i = index2; i < size2; ++i) |
| newList2.add(list2.get(i)); |
| if (compare(newList1, newList2, level)) { |
| addWarning("skipped optional element(s) in left schema",elem1,elem2); |
| return true; |
| } |
| addError("different complex element structures",elem1,elem2); |
| } |
| if (isOptional(elem2)) { |
| // skip over this one and compare remaining elements |
| List<XSDTerm> newList1 = new ArrayList<XSDTerm>(); |
| List<XSDTerm> newList2 = new ArrayList<XSDTerm>(); |
| for (int i = index1; i < size1; ++i) |
| newList1.add(list1.get(i)); |
| for (int i = index2 + 1; i < size2; ++i) |
| newList2.add(list2.get(i)); |
| if (compare(newList1, newList2, level)) { |
| addWarning("skipped optional element(s) in right schema",elem1,elem2); |
| return true; |
| } |
| addError("different complex element structures",elem1,elem2); |
| } |
| } |
| addError("different complex element structures",elem1,elem2); |
| return false; |
| } |
| |
| List<XSDAttributeDeclaration> attrs1 = getAttributeDeclarations(elem1); |
| List<XSDAttributeDeclaration> attrs2 = getAttributeDeclarations(elem2); |
| if (attrs1.size() != attrs2.size()) { |
| addError("different number of attributes",elem1,elem2); |
| return false; |
| } |
| for (int i = 0; i < attrs1.size(); ++i) { |
| XSDAttributeDeclaration attr1 = attrs1.get(i); |
| XSDAttributeDeclaration attr2 = attrs2.get(i); |
| if (!attr1.getQName().equals(attr2.getQName())) { |
| addError("different attribute names: "+attr1.getQName()+" vs "+attr2.getQName(),elem1,elem2); |
| return false; |
| } |
| String value1 = attr1.getLexicalValue(); |
| String value2 = attr2.getLexicalValue(); |
| if (value1==null) |
| value1 = ""; |
| if (value2==null) |
| value2 = ""; |
| if (!value1.equals(value2)) { |
| addError("different attribute values: "+attr1.getLexicalValue()+" vs "+attr2.getLexicalValue(),elem1,elem2); |
| return false; |
| } |
| } |
| |
| } else if (term1 instanceof XSDWildcard && !(term2 instanceof XSDWildcard) ) { |
| // left schema term is a wildcard, right schema is not |
| int min = getMinOccurs(term1); |
| int max = getMinOccurs(term1); |
| if (max==-1) |
| max = size1; |
| |
| for (int n=min; n<=max; ++n) { |
| // skip over this one and compare remaining elements |
| List<XSDTerm> newList1 = new ArrayList<XSDTerm>(); |
| List<XSDTerm> newList2 = new ArrayList<XSDTerm>(); |
| for (int i = index1 + 1 + n; i < size1; ++i) |
| newList1.add(list1.get(i)); |
| for (int i = index2; i < size2; ++i) |
| newList2.add(list2.get(i)); |
| if (compare(newList1, newList2, level)) { |
| addWarning("skipped optional element(s) in left schema",term1,term2); |
| return true; |
| } |
| } |
| addError("different complex element structures",term1,term2); |
| return false; |
| } else if (term1 instanceof XSDWildcard && !(term2 instanceof XSDWildcard) ) { |
| // right schema is a wildcard, left schema is not |
| int min = getMinOccurs(term2); |
| int max = getMinOccurs(term2); |
| if (max==-1) |
| max = size2; |
| |
| for (int n=min; n<=max; ++n) { |
| // skip over this one and compare remaining elements |
| List<XSDTerm> newList1 = new ArrayList<XSDTerm>(); |
| List<XSDTerm> newList2 = new ArrayList<XSDTerm>(); |
| for (int i = index1; i < size1; ++i) |
| newList1.add(list1.get(i)); |
| for (int i = index2 + 1 + n; i < size2; ++i) |
| newList2.add(list2.get(i)); |
| if (compare(newList1, newList2, level)) { |
| addWarning("skipped optional element(s) in right schema",term1,term2); |
| return true; |
| } |
| } |
| addError("different complex element structures",term1,term2); |
| return false; |
| } else if (term1 instanceof XSDWildcard && term2 instanceof XSDWildcard) { |
| // both wildcards - it's a match! |
| int min1 = getMinOccurs(term1); |
| int max1 = getMinOccurs(term1); |
| int min2 = getMinOccurs(term2); |
| int max2 = getMinOccurs(term2); |
| if (min1!=min2 || max1!=max2) { |
| // not possible |
| addError("different <xsd:any> cardinality: "+min1+" to "+max1+" vs "+min2+" to "+max2,term1,term2); |
| } |
| } |
| } |
| |
| ++index1; |
| ++index2; |
| } |
| |
| // any leftovers? they must be optional |
| if (strict && size1 != size2) { |
| addError("different number of elements: "+size1+" vs "+size2,term1,term2); |
| return false; |
| } |
| |
| if (index1 < size1) { |
| dump("Additional elements in left schema"); |
| while (index1 < size1) { |
| term1 = list1.get(index1); |
| if (isOptional(term1)) { |
| dump("Ignoring optional element", term1, null, 1); |
| addWarning("skipped optional element in left schema",term1,term2); |
| term1 = list2.get(++index1); |
| } else { |
| addError("additional elements in left schema",term1,term2); |
| return false; |
| } |
| } |
| } |
| |
| if (index2 < size2) { |
| dump("Additional elements in right schema"); |
| while (index2 < size2) { |
| term2 = list2.get(index2); |
| if (isOptional(term2)) { |
| dump("Ignoring optional element", term2, null, 1); |
| addWarning("skipped optional element in right schema",term1,term2); |
| term2 = list2.get(++index2); |
| } else { |
| addError("additional elements in right schema",term1,term2); |
| return false; |
| } |
| } |
| } |
| |
| } catch (Exception e) { |
| addError("caught exception: "+e.toString(),term1,term2); |
| e.printStackTrace(); |
| return false; |
| } |
| |
| if (level==0) |
| dump("*** Schemas are compatible"); |
| |
| return true; |
| } |
| |
| /** |
| * Returns the data type name of the given element, including base types. |
| * |
| * @param elem - the element |
| * @return data type name hierarchy as a ":" separated string |
| */ |
| protected String getTypeNameHierarchy(XSDElementDeclaration elem) { |
| String s = ""; |
| Stack<String> names = new Stack<String>(); |
| XSDTypeDefinition type = elem.getType(); |
| while (type != type.getBaseType()) { |
| String name = type.getName(); |
| if (name != null) |
| names.push(name); |
| type = type.getBaseType(); |
| } |
| while (!names.isEmpty()) { |
| if (s.isEmpty()) |
| s = names.pop(); |
| else |
| s = s + ":" + names.pop(); |
| } |
| return s; |
| } |
| |
| private boolean compareQNames(XSDNamedComponent elem1, XSDNamedComponent elem2) { |
| |
| String name1 = elem1.getName(); |
| String name2 = elem2.getName(); |
| if (name1==null || name2==null) { |
| if (name1==name2) |
| return true; |
| return false; |
| } |
| if (name1.equals(name2)) { |
| if (elem1.getTargetNamespace() == null || elem1.getTargetNamespace().isEmpty() |
| && elem2.getTargetNamespace() == null || elem2.getTargetNamespace().isEmpty()) |
| return true; |
| |
| if (elem1.getTargetNamespace().equals(elem2.getTargetNamespace())) |
| return true; |
| |
| if ( elem1.getSchema().getTargetNamespace().equals(elem2.getSchema().getTargetNamespace()) ) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Returns a list of immediate children for the specified element. |
| * |
| * @param element - the parent element |
| * @return A list of XSDTerm objects |
| */ |
| protected final List<XSDTerm> getChildTerms(XSDElementDeclaration element) { |
| return getChildTerms(element.getType()); |
| } |
| |
| /** |
| * Returns a list of immediate children for the specified XSD type. |
| * |
| * @param type - the parent type |
| * @return A list of XSDTerm objects |
| */ |
| protected final List<XSDTerm> getChildTerms(XSDTypeDefinition type) { |
| final ArrayList<XSDTerm> terms = new ArrayList<XSDTerm>(); |
| |
| TypeWalker.Visitor visitor = new TypeWalker.Visitor() { |
| public boolean visit(XSDTypeDefinition type) { |
| // simple types don't have children |
| if (type instanceof XSDSimpleTypeDefinition) |
| return true; |
| |
| XSDComplexTypeDefinition cType = (XSDComplexTypeDefinition) type; |
| |
| visitTerms(cType, new TermVisitor() { |
| public void visit(XSDParticle particle) { |
| // element declaration, or wildcard: add to list |
| XSDParticleContent content = particle.getContent(); |
| if (content instanceof XSDElementDeclaration) { |
| XSDElementDeclaration decl = (XSDElementDeclaration) particle.getContent(); |
| |
| if (decl.isElementDeclarationReference()) |
| decl = decl.getResolvedElementDeclaration(); |
| // System.out.println("Adding "+decl.getName()); |
| terms.add(decl); |
| } else if (content instanceof XSDWildcard) { |
| // System.out.println("Adding <xsd:any>"); |
| terms.add((XSDWildcard) content); |
| } |
| } |
| }); |
| |
| return true; |
| } |
| }; |
| |
| TypeWalker walker = new TypeWalker(type); |
| walker.walk(visitor); |
| |
| return terms; |
| } |
| |
| /** |
| * Returns the value of the "minOccurs" attribute for the given XSD element. |
| * |
| * @param term - the XSD element |
| * @return numerical value of "minOccurs" or 1 if the element does not specify |
| */ |
| public int getMinOccurs(XSDTerm term) { |
| String smin = term.getElement().getAttribute("minOccurs"); |
| int min = 1; |
| if (smin!=null && !smin.isEmpty()) { |
| try { |
| min = Integer.parseInt(smin); |
| } catch (NumberFormatException e) { |
| } |
| } |
| return min; |
| } |
| |
| /** |
| * Returns the value of the "maxOccurs" attribute for the given XSD element. |
| * |
| * @param term - the XSD element |
| * @return numerical value of "maxOccurs" or 1 if the element does not specify |
| */ |
| public int getMaxOccurs(XSDTerm term) { |
| String smax = term.getElement().getAttribute("maxOccurs"); |
| int max = 1; |
| if (smax!=null && !smax.isEmpty()) { |
| try { |
| max = Integer.parseInt(smax); |
| } catch (NumberFormatException e) { |
| if (smax.equalsIgnoreCase("unbounded")) |
| max = -1; |
| } |
| } |
| return max; |
| } |
| |
| /** |
| * Returns true if the specified XSD element is optional. |
| * |
| * @param term |
| * @return true if the element has "minOccurs=0" |
| */ |
| protected boolean isOptional(XSDTerm term) { |
| |
| if (getMinOccurs(term)==0) |
| return true; |
| return false; |
| } |
| |
| /** |
| * Examine the content of a complex type and visit each of its particles. |
| * This will expand <xsd:sequence>, <xsd:choice>, <xsd:all>, <xsd:group> |
| * and <xsd:any> elements. |
| * |
| * @param cType - the complex type to examine |
| * @param visitor - a TermVisitor which will be called for each particle found |
| */ |
| private void visitTerms(XSDComplexTypeDefinition cType, TermVisitor visitor) { |
| |
| // simple types are leaf nodes |
| if (cType.getContent() == null || (cType.getContent() instanceof XSDSimpleTypeDefinition)) |
| return; |
| |
| // the last particle visited; used to detect <xsd:any> elements |
| XSDParticleContent lastVisited = null; |
| |
| // use a queue to simulate the recursion |
| LinkedList<XSDParticle> queue = new LinkedList<XSDParticle>(); |
| queue.addLast((XSDParticle) cType.getContent()); |
| |
| while (!queue.isEmpty()) { |
| XSDParticle particle = (XSDParticle) queue.removeFirst(); |
| |
| // analyze type of particle content |
| int pType = org.eclipse.xsd.util.XSDUtil.nodeType(particle.getElement()); |
| if (pType == XSDConstants.ELEMENT_ELEMENT) { |
| lastVisited = particle.getContent(); |
| visitor.visit(particle); |
| } else { |
| // model group |
| XSDModelGroup modelGroup = null; |
| switch (pType) { |
| case XSDConstants.GROUP_ELEMENT: |
| XSDModelGroupDefinition grpDef = (XSDModelGroupDefinition) particle.getContent(); |
| if (grpDef.isModelGroupDefinitionReference()) |
| grpDef = grpDef.getResolvedModelGroupDefinition(); |
| |
| modelGroup = grpDef.getModelGroup(); |
| break; |
| |
| case XSDConstants.CHOICE_ELEMENT: |
| case XSDConstants.ALL_ELEMENT: |
| case XSDConstants.SEQUENCE_ELEMENT: |
| modelGroup = (XSDModelGroup) particle.getContent(); |
| break; |
| |
| case XSDConstants.ANY_ELEMENT: |
| // see forum post at: |
| // http://www.eclipse.org/forums/index.php?t=msg&th=20437&start=0&S=52ae90dcc09745f37034e330b91695cd |
| // |
| // The XSDWildcard seems to be emitted in the case where an element has no type information; |
| // and it is also emitted in response to an actual xsd:any element appearing in the schema. |
| // |
| // In both cases, the XSDWildcard appears the same (surprisingly it refers to a DOM element |
| // from Xerces of xsd:any). there is confusion here between elements of type anyType, i..e., |
| // <xsd:element name="x" type=xsd:anyType"/> verses element wildcards <xsd:any>. When matching |
| // element content using the DFA returned by XSDParticle, each element will match either an |
| // element declaration or a wildcard, which you can tell apart easily by whether you've matched |
| // an XSDElementDeclaration or an XSDWildcard. |
| if (lastVisited!=null) { |
| // found an <xsd:any> element - go visit it! |
| lastVisited = particle.getContent(); |
| visitor.visit(particle); |
| } |
| break; |
| |
| default: |
| // TODO: do we need to handle additional XSD node types? |
| break; |
| } |
| |
| if (modelGroup != null) { |
| // enque all particles in the group |
| List<XSDParticle> particles = modelGroup.getParticles(); |
| for (XSDParticle p : particles) { |
| queue.addLast(p); |
| } |
| |
| lastVisited = null; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns a list of all attribute declarations declared in the type or any |
| * base type, of the specified element. |
| * |
| * @param element - the element |
| * @return a list of XSDAttributeDeclaration objects |
| */ |
| public final List<XSDAttributeDeclaration> getAttributeDeclarations(XSDElementDeclaration element) { |
| final ArrayList<XSDAttributeDeclaration> attributes = new ArrayList<XSDAttributeDeclaration>(); |
| |
| // walk up the type hierarchy of the element to generate a list of atts |
| TypeWalker walker = new TypeWalker(element.getType()); |
| |
| TypeWalker.Visitor visitor = new TypeWalker.Visitor() { |
| public boolean visit(XSDTypeDefinition type) { |
| |
| // simple types dont have attributes |
| if (type instanceof XSDSimpleTypeDefinition) |
| return true; |
| |
| XSDComplexTypeDefinition cType = (XSDComplexTypeDefinition) type; |
| |
| // get all the attribute content (groups,or uses) and add to list |
| List<XSDAttributeGroupContent> contents = cType.getAttributeContents(); |
| for (XSDAttributeGroupContent content : contents) { |
| if (content instanceof XSDAttributeUse) { |
| // an attribute, add it to the list |
| XSDAttributeUse use = (XSDAttributeUse) content; |
| attributes.add(use.getAttributeDeclaration()); |
| } else if (content instanceof XSDAttributeGroupDefinition) { |
| // attribute group, add all atts in group to list |
| XSDAttributeGroupDefinition attGrp = (XSDAttributeGroupDefinition) content; |
| |
| if (attGrp.isAttributeGroupDefinitionReference()) { |
| attGrp = attGrp.getResolvedAttributeGroupDefinition(); |
| } |
| |
| List<XSDAttributeUse> uses = attGrp.getAttributeUses(); |
| for (XSDAttributeUse use : uses) { |
| attributes.add(use.getAttributeDeclaration()); |
| } |
| } |
| } |
| |
| return true; |
| } |
| }; |
| |
| walker.walk(visitor); |
| return attributes; |
| } |
| |
| /** |
| * Returns a list diagnostics of that may have been created |
| * during the comparison |
| * |
| * @return a list of XSDDiagnostic objects |
| */ |
| public List<XSDDiagnostic> getDiagnostics() { |
| if (diagnostics==null) { |
| diagnostics = new ArrayList<XSDDiagnostic>(); |
| } |
| return diagnostics; |
| } |
| |
| /** |
| * Convenience method for formatting diagnostics as strings |
| * |
| * @param index - the index into the diagnostics array |
| * @return a nicely formatted string |
| */ |
| public String getDiagnostic(int index) { |
| String msg = ""; |
| |
| if (diagnostics!=null && index>=0 && index<diagnostics.size()) { |
| XSDDiagnostic d = diagnostics.get(index); |
| String name1 = ""; |
| String name2 = ""; |
| String schema1 = ""; |
| String schema2 = ""; |
| XSDTerm comp1 = null; |
| XSDTerm comp2 = null; |
| EList<XSDConcreteComponent> components = d.getComponents(); |
| if (components.size()>0 && components.get(0) instanceof XSDTerm) |
| comp1 = (XSDTerm)components.get(0); |
| if (components.size()>1 && components.get(1) instanceof XSDTerm) |
| comp2 = (XSDTerm)components.get(1); |
| |
| if (comp1 instanceof XSDElementDeclaration) { |
| name1 = ((XSDElementDeclaration)comp1).getQName(); |
| schema1 = comp1.eResource().getURI().toString(); |
| } |
| else if (comp1 instanceof XSDWildcard) { |
| name1 = "<xsd:any>"; |
| schema1 = comp1.eResource().getURI().toString(); |
| } |
| if (comp2 instanceof XSDElementDeclaration) { |
| name2 = ((XSDElementDeclaration)comp2).getQName(); |
| schema2 = comp2.eResource().getURI().toString(); |
| } |
| else if (comp2 instanceof XSDWildcard) { |
| name2 = "<xsd:any>"; |
| schema2 = comp2.eResource().getURI().toString(); |
| } |
| |
| if ( comp1!=null && comp2!=null ) { |
| msg = "Element <" + name1 + ">" + |
| " in " + schema1 + |
| " differs from <" + name2 + ">"; |
| if (!schema1.equals(schema2)) |
| msg += " in " + schema2; |
| msg += " - " + d.getMessage(); |
| } |
| else { |
| msg = |
| "Schema " + d.getLocationURI() + |
| " - " + d.getMessage(); |
| } |
| } |
| return msg; |
| } |
| |
| /** |
| * Creates a new diagnostic and adds it to our list. |
| * |
| * @param severity - one of the XSDDiagnosticSeverity values (WARNING, ERROR, etc.) |
| * @param msg - a human-readable message to associate with the diagnostic |
| * @param comp1 - the "left" schema component |
| * @param comp2 - the "right" schema component |
| * @return a newly constructed XSDDiagnostic object |
| */ |
| protected XSDDiagnostic addDiagnostic(int severity, String msg, XSDConcreteComponent comp1, XSDConcreteComponent comp2) { |
| XSDDiagnostic diag = XSDFactory.eINSTANCE.createXSDDiagnostic(); |
| diag.setSeverity(XSDDiagnosticSeverity.get(severity)); |
| diag.setMessage(msg); |
| diag.getComponents().add(comp1); |
| diag.getComponents().add(comp2); |
| getDiagnostics().add(diag); |
| |
| if (debug) |
| dump(getDiagnostic(getDiagnostics().size()-1)); |
| |
| return diag; |
| } |
| |
| /** |
| * Convenience method for creating a WARNING diagnostic |
| * |
| * @param msg - a human-readable message to associate with the diagnostic |
| * @param comp1 - the "left" schema component |
| * @param comp2 - the "right" schema component |
| * @return a newly constructed XSDDiagnostic object |
| */ |
| protected XSDDiagnostic addWarning(String msg, XSDConcreteComponent comp1, XSDConcreteComponent comp2) { |
| return addDiagnostic(XSDDiagnosticSeverity.WARNING, msg, comp1, comp2); |
| } |
| |
| /** |
| * Convenience method for creating a WARNING diagnostic |
| * |
| * @param msg - a human-readable message to associate with the diagnostic |
| * @param comp1 - the "left" schema component |
| * @param comp2 - the "right" schema component |
| * @return a newly constructed XSDDiagnostic object |
| */ |
| protected XSDDiagnostic addError(String msg, XSDConcreteComponent comp1, XSDConcreteComponent comp2) { |
| return addDiagnostic(XSDDiagnosticSeverity.ERROR, msg, comp1, comp2); |
| } |
| |
| /** |
| * Debug message printer |
| * |
| * @param label - a text string to print to stderr |
| */ |
| private void dump(String label) { |
| |
| if (debug) |
| dump(label, null, null, 0); |
| } |
| |
| /** |
| * Debug message printer |
| * |
| * @param label - text string |
| * @param term - an XSD element to dump |
| * @param type - and its type |
| * @param level - indent level |
| */ |
| private void dump(String label, XSDTerm term, XSDTypeDefinition type, int level) { |
| |
| if (debug) { |
| if (term != null) { |
| StringBuilder indent = new StringBuilder(); |
| for (int i = 0; i < level; ++i) |
| indent.append( " " ); |
| |
| if (term instanceof XSDElementDeclaration) { |
| XSDElementDeclaration decl = (XSDElementDeclaration) term; |
| if (type instanceof XSDSimpleTypeDefinition) |
| System.err.println(label + indent + "<" + decl.getName() + "> type=\"" |
| + this.getTypeNameHierarchy(decl)+"\""); |
| else if (type instanceof XSDComplexTypeDefinition || type == null) |
| System.err.println(label + indent + "<" + decl.getName() + ">"); |
| else |
| System.err.println("dump: unknown XSD type: " + type.getClass().toString()); |
| } else if (term instanceof XSDWildcard) { |
| System.err.println(label + indent + "<any/>"); |
| } else |
| System.err.println("dump: unknown term: " + term.getClass().toString()); |
| } else |
| System.err.println(label); |
| } |
| } |
| |
| /** |
| * Simple visitor interface for complex types |
| */ |
| private interface TermVisitor { |
| void visit(XSDParticle particle); |
| } |
| |
| /** |
| * XSD type hierarchy walker that visits each XSD type from the bottom-up |
| */ |
| private static class TypeWalker { |
| |
| // bottom of the type hierarchy |
| XSDTypeDefinition base; |
| |
| public TypeWalker(XSDTypeDefinition base) { |
| this.base = base; |
| } |
| |
| public void walk(Visitor visitor) { |
| |
| XSDTypeDefinition type = base; |
| |
| while(type != null) { |
| if (!visitor.visit(type)) |
| break; |
| // walk up the type hierarchy to the top |
| if (type.equals(type.getBaseType())) |
| break; |
| type = type.getBaseType(); |
| } |
| } |
| |
| public interface Visitor { |
| boolean visit(XSDTypeDefinition type); |
| } |
| } |
| |
| private static class XSDTermTuple { |
| public XSDTerm term1, term2; |
| public XSDTermTuple(XSDTerm term1, XSDTerm term2) { |
| this.term1 = term1; |
| this.term2 = term2; |
| } |
| } |
| } |
